Module moody.m.b_send
Generated wrapper for BSend Solidity contract.
Expand source code
"""Generated wrapper for BSend Solidity contract."""
# pylint: disable=too-many-arguments
import json
import time
from typing import ( # pylint: disable=unused-import
List,
Optional,
Tuple,
Union,
)
from eth_utils import to_checksum_address
from hexbytes import HexBytes
from moody import Bolors
from moody.libeb import MiliDoS
from moody.m.bases import ContractMethod, Validator, ContractBase, Signatures
from moody.m.tx_params import TxParams
from web3.contract import ContractFunction
from web3.datastructures import AttributeDict
from web3.exceptions import ContractLogicError
# Try to import a custom validator class definition; if there isn't one,
# declare one that we can instantiate for the default argument to the
# constructor for BSend below.
try:
# both mypy and pylint complain about what we're doing here, but this
# works just fine, so their messages have been disabled here.
from . import ( # type: ignore # pylint: disable=import-self
BSendValidator,
)
except ImportError:
class BSendValidator( # type: ignore
Validator
):
"""No-op input validator."""
try:
from .middleware import MIDDLEWARE # type: ignore
except ImportError:
pass
class AddSignerMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the addSigner method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("addSigner")
def validate_and_normalize_inputs(self, account: str) -> any:
"""Validate the inputs to the addSigner method."""
self.validator.assert_valid(
method_name='addSigner',
parameter_name='account',
argument_value=account,
)
account = self.validate_and_checksum_address(account)
return (account)
def block_send(self, account: str, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(account)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: add_signer")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(account) = self.validate_and_normalize_inputs(account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(account).transact(tx_params.as_dict())
def build_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(account) = self.validate_and_normalize_inputs(account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(account).buildTransaction(tx_params.as_dict())
def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(account) = self.validate_and_normalize_inputs(account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(account).estimateGas(tx_params.as_dict())
class BulkSendTokenMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the bulkSendToken method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("bulkSendToken")
def validate_and_normalize_inputs(self, token_addr: str, addresses: List[str], amounts: List[int]) -> any:
"""Validate the inputs to the bulkSendToken method."""
self.validator.assert_valid(
method_name='bulkSendToken',
parameter_name='tokenAddr',
argument_value=token_addr,
)
token_addr = self.validate_and_checksum_address(token_addr)
self.validator.assert_valid(
method_name='bulkSendToken',
parameter_name='addresses',
argument_value=addresses,
)
self.validator.assert_valid(
method_name='bulkSendToken',
parameter_name='amounts',
argument_value=amounts,
)
return (token_addr, addresses, amounts)
def block_send(self, token_addr: str, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(token_addr, addresses, amounts)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_token")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, addresses, amounts).transact(tx_params.as_dict())
def build_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, addresses, amounts).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, addresses, amounts).estimateGas(tx_params.as_dict())
class BulkSendTrxMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the bulkSendTrx method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("bulkSendTrx")
def validate_and_normalize_inputs(self, addresses: List[str], amounts: List[int]) -> any:
"""Validate the inputs to the bulkSendTrx method."""
self.validator.assert_valid(
method_name='bulkSendTrx',
parameter_name='addresses',
argument_value=addresses,
)
self.validator.assert_valid(
method_name='bulkSendTrx',
parameter_name='amounts',
argument_value=amounts,
)
return (addresses, amounts)
def block_send(self, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(addresses, amounts)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_trx")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addresses, amounts).transact(tx_params.as_dict())
def build_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addresses, amounts).buildTransaction(tx_params.as_dict())
def estimate_gas(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addresses, amounts).estimateGas(tx_params.as_dict())
class DepositMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the deposit method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address)
self._underlying_method = contract_function
self.sign = validator.getSignature("deposit")
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method()
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: deposit")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().transact(tx_params.as_dict())
def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().buildTransaction(tx_params.as_dict())
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())
class EthSendFeeMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the ethSendFee method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address)
self._underlying_method = contract_function
self.sign = validator.getSignature("ethSendFee")
def block_call(self, debug: bool = False) -> int:
_fn = self._underlying_method()
returned = _fn.call({
'from': self._operate
})
return int(returned)
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())
class GetBalanceMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the getBalance method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("getBalance")
def validate_and_normalize_inputs(self, addr: str) -> any:
"""Validate the inputs to the getBalance method."""
self.validator.assert_valid(
method_name='getBalance',
parameter_name='addr',
argument_value=addr,
)
addr = self.validate_and_checksum_address(addr)
return (addr)
def block_call(self, addr: str, debug: bool = False) -> int:
_fn = self._underlying_method(addr)
returned = _fn.call({
'from': self._operate
})
return int(returned)
def estimate_gas(self, addr: str, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(addr) = self.validate_and_normalize_inputs(addr)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addr).estimateGas(tx_params.as_dict())
class IsSignerMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the isSigner method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("isSigner")
def validate_and_normalize_inputs(self, account: str) -> any:
"""Validate the inputs to the isSigner method."""
self.validator.assert_valid(
method_name='isSigner',
parameter_name='account',
argument_value=account,
)
account = self.validate_and_checksum_address(account)
return (account)
def block_call(self, account: str, debug: bool = False) -> bool:
_fn = self._underlying_method(account)
returned = _fn.call({
'from': self._operate
})
return bool(returned)
def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(account) = self.validate_and_normalize_inputs(account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(account).estimateGas(tx_params.as_dict())
class RenounceSignerMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the renounceSigner method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address)
self._underlying_method = contract_function
self.sign = validator.getSignature("renounceSigner")
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method()
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: renounce_signer")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().transact(tx_params.as_dict())
def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().buildTransaction(tx_params.as_dict())
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())
class SetEthFeeMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the setEthFee method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("setEthFee")
def validate_and_normalize_inputs(self, eth_send_fee: int) -> any:
"""Validate the inputs to the setEthFee method."""
self.validator.assert_valid(
method_name='setEthFee',
parameter_name='_ethSendFee',
argument_value=eth_send_fee,
)
# safeguard against fractional inputs
eth_send_fee = int(eth_send_fee)
return (eth_send_fee)
def block_send(self, eth_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(eth_send_fee)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_eth_fee")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(eth_send_fee).transact(tx_params.as_dict())
def build_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(eth_send_fee).buildTransaction(tx_params.as_dict())
def estimate_gas(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(eth_send_fee).estimateGas(tx_params.as_dict())
class SetTokenFeeMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the setTokenFee method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("setTokenFee")
def validate_and_normalize_inputs(self, token_send_fee: int) -> any:
"""Validate the inputs to the setTokenFee method."""
self.validator.assert_valid(
method_name='setTokenFee',
parameter_name='_tokenSendFee',
argument_value=token_send_fee,
)
# safeguard against fractional inputs
token_send_fee = int(token_send_fee)
return (token_send_fee)
def block_send(self, token_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(token_send_fee)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_token_fee")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(token_send_fee) = self.validate_and_normalize_inputs(token_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_send_fee).transact(tx_params.as_dict())
def build_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(token_send_fee) = self.validate_and_normalize_inputs(token_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_send_fee).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(token_send_fee) = self.validate_and_normalize_inputs(token_send_fee)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_send_fee).estimateGas(tx_params.as_dict())
class TokenSendFeeMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the tokenSendFee method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address)
self._underlying_method = contract_function
self.sign = validator.getSignature("tokenSendFee")
def block_call(self, debug: bool = False) -> int:
_fn = self._underlying_method()
returned = _fn.call({
'from': self._operate
})
return int(returned)
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())
class WithdrawEtherMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the withdrawEther method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("withdrawEther")
def validate_and_normalize_inputs(self, addr: str, amount: int) -> any:
"""Validate the inputs to the withdrawEther method."""
self.validator.assert_valid(
method_name='withdrawEther',
parameter_name='addr',
argument_value=addr,
)
addr = self.validate_and_checksum_address(addr)
self.validator.assert_valid(
method_name='withdrawEther',
parameter_name='amount',
argument_value=amount,
)
# safeguard against fractional inputs
amount = int(amount)
return (addr, amount)
def block_send(self, addr: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(addr, amount)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_ether")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(addr, amount) = self.validate_and_normalize_inputs(addr, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addr, amount).transact(tx_params.as_dict())
def build_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(addr, amount) = self.validate_and_normalize_inputs(addr, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addr, amount).buildTransaction(tx_params.as_dict())
def estimate_gas(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(addr, amount) = self.validate_and_normalize_inputs(addr, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(addr, amount).estimateGas(tx_params.as_dict())
class WithdrawTokenMethod(ContractMethod): # pylint: disable=invalid-name
"""Various interfaces to the withdrawToken method."""
def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None):
"""Persist instance data."""
super().__init__(elib, contract_address, validator)
self._underlying_method = contract_function
self.sign = validator.getSignature("withdrawToken")
def validate_and_normalize_inputs(self, token_addr: str, to: str, amount: int) -> any:
"""Validate the inputs to the withdrawToken method."""
self.validator.assert_valid(
method_name='withdrawToken',
parameter_name='tokenAddr',
argument_value=token_addr,
)
token_addr = self.validate_and_checksum_address(token_addr)
self.validator.assert_valid(
method_name='withdrawToken',
parameter_name='_to',
argument_value=to,
)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(
method_name='withdrawToken',
parameter_name='_amount',
argument_value=amount,
)
# safeguard against fractional inputs
amount = int(amount)
return (token_addr, to, amount)
def block_send(self, token_addr: str, to: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool:
"""Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.
"""
_fn = self._underlying_method(token_addr, to, amount)
try:
_t = _fn.buildTransaction({
'from': self._operate,
'gas': gas,
'gasPrice': price
})
_t['nonce'] = self._web3_eth.getTransactionCount(self._operate)
if val > 0:
_t['value'] = val
if debug:
print(f"======== Signing ✅ by {self._operate}")
print(f"======== Transaction ✅ check")
print(_t)
if 'data' in _t:
signed = self._web3_eth.account.sign_transaction(_t)
txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction)
tx_receipt = None
if receiptListen is True:
print(f"======== awaiting Confirmation 🚸️ {self.sign}")
tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash)
if debug:
print("======== TX Result ✅")
print(tx_receipt)
print(f"======== TX blockHash ✅")
if tx_receipt is not None:
print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}")
else:
print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash")
if receiptListen is False:
time.sleep(self._wait)
except ContractLogicError as er:
print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_token")
except ValueError as err:
if "message" in err.args[0]:
message = err.args[0]["message"]
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}")
else:
print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def send_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
"""Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
"""
(token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, to, amount).transact(tx_params.as_dict())
def build_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> dict:
"""Construct calldata to be used as input to the method."""
(token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, to, amount).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> int:
"""Estimate gas consumption of method call."""
(token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_addr, to, amount).estimateGas(tx_params.as_dict())
class SignatureGenerator(Signatures):
"""
The signature is generated for this and it is installed.
"""
def __init__(self, abi: any):
super().__init__(abi)
def add_signer(self) -> str:
return self._function_signatures["addSigner"]
def bulk_send_token(self) -> str:
return self._function_signatures["bulkSendToken"]
def bulk_send_trx(self) -> str:
return self._function_signatures["bulkSendTrx"]
def deposit(self) -> str:
return self._function_signatures["deposit"]
def eth_send_fee(self) -> str:
return self._function_signatures["ethSendFee"]
def get_balance(self) -> str:
return self._function_signatures["getBalance"]
def is_signer(self) -> str:
return self._function_signatures["isSigner"]
def renounce_signer(self) -> str:
return self._function_signatures["renounceSigner"]
def set_eth_fee(self) -> str:
return self._function_signatures["setEthFee"]
def set_token_fee(self) -> str:
return self._function_signatures["setTokenFee"]
def token_send_fee(self) -> str:
return self._function_signatures["tokenSendFee"]
def withdraw_ether(self) -> str:
return self._function_signatures["withdrawEther"]
def withdraw_token(self) -> str:
return self._function_signatures["withdrawToken"]
# pylint: disable=too-many-public-methods,too-many-instance-attributes
class BSend(ContractBase):
"""Wrapper class for BSend Solidity contract."""
_fn_add_signer: AddSignerMethod
"""Constructor-initialized instance of
:class:`AddSignerMethod`.
"""
_fn_bulk_send_token: BulkSendTokenMethod
"""Constructor-initialized instance of
:class:`BulkSendTokenMethod`.
"""
_fn_bulk_send_trx: BulkSendTrxMethod
"""Constructor-initialized instance of
:class:`BulkSendTrxMethod`.
"""
_fn_deposit: DepositMethod
"""Constructor-initialized instance of
:class:`DepositMethod`.
"""
_fn_eth_send_fee: EthSendFeeMethod
"""Constructor-initialized instance of
:class:`EthSendFeeMethod`.
"""
_fn_get_balance: GetBalanceMethod
"""Constructor-initialized instance of
:class:`GetBalanceMethod`.
"""
_fn_is_signer: IsSignerMethod
"""Constructor-initialized instance of
:class:`IsSignerMethod`.
"""
_fn_renounce_signer: RenounceSignerMethod
"""Constructor-initialized instance of
:class:`RenounceSignerMethod`.
"""
_fn_set_eth_fee: SetEthFeeMethod
"""Constructor-initialized instance of
:class:`SetEthFeeMethod`.
"""
_fn_set_token_fee: SetTokenFeeMethod
"""Constructor-initialized instance of
:class:`SetTokenFeeMethod`.
"""
_fn_token_send_fee: TokenSendFeeMethod
"""Constructor-initialized instance of
:class:`TokenSendFeeMethod`.
"""
_fn_withdraw_ether: WithdrawEtherMethod
"""Constructor-initialized instance of
:class:`WithdrawEtherMethod`.
"""
_fn_withdraw_token: WithdrawTokenMethod
"""Constructor-initialized instance of
:class:`WithdrawTokenMethod`.
"""
SIGNATURES: SignatureGenerator = None
def __init__(
self,
core_lib: MiliDoS,
contract_address: str,
validator: BSendValidator = None,
):
"""Get an instance of wrapper for smart contract.
"""
# pylint: disable=too-many-statements
super().__init__()
self.contract_address = contract_address
web3 = core_lib.w3
if not validator:
validator = BSendValidator(web3, contract_address)
# if any middleware was imported, inject it
try:
MIDDLEWARE
except NameError:
pass
else:
try:
for middleware in MIDDLEWARE:
web3.middleware_onion.inject(
middleware['function'], layer=middleware['layer'],
)
except ValueError as value_error:
if value_error.args == ("You can't add the same un-named instance twice",):
pass
self._web3_eth = web3.eth
functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=BSend.abi()).functions
signed = SignatureGenerator(BSend.abi())
validator.bindSignatures(signed)
self.SIGNATURES = signed
self._fn_add_signer = AddSignerMethod(core_lib, contract_address, functions.addSigner, validator)
self._fn_bulk_send_token = BulkSendTokenMethod(core_lib, contract_address, functions.bulkSendToken, validator)
self._fn_bulk_send_trx = BulkSendTrxMethod(core_lib, contract_address, functions.bulkSendTrx, validator)
self._fn_deposit = DepositMethod(core_lib, contract_address, functions.deposit, validator)
self._fn_eth_send_fee = EthSendFeeMethod(core_lib, contract_address, functions.ethSendFee, validator)
self._fn_get_balance = GetBalanceMethod(core_lib, contract_address, functions.getBalance, validator)
self._fn_is_signer = IsSignerMethod(core_lib, contract_address, functions.isSigner, validator)
self._fn_renounce_signer = RenounceSignerMethod(core_lib, contract_address, functions.renounceSigner, validator)
self._fn_set_eth_fee = SetEthFeeMethod(core_lib, contract_address, functions.setEthFee, validator)
self._fn_set_token_fee = SetTokenFeeMethod(core_lib, contract_address, functions.setTokenFee, validator)
self._fn_token_send_fee = TokenSendFeeMethod(core_lib, contract_address, functions.tokenSendFee, validator)
self._fn_withdraw_ether = WithdrawEtherMethod(core_lib, contract_address, functions.withdrawEther, validator)
self._fn_withdraw_token = WithdrawTokenMethod(core_lib, contract_address, functions.withdrawToken, validator)
def event_signer_added(
self, tx_hash: Union[HexBytes, bytes]
) -> Tuple[AttributeDict]:
"""
Implementation of event signer_added in contract BSend
Get log entry for SignerAdded event.
:param tx_hash: hash of transaction emitting SignerAdded event
"""
tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerAdded().processReceipt(tx_receipt)
def event_signer_removed(
self, tx_hash: Union[HexBytes, bytes]
) -> Tuple[AttributeDict]:
"""
Implementation of event signer_removed in contract BSend
Get log entry for SignerRemoved event.
:param tx_hash: hash of transaction emitting SignerRemoved event
"""
tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash)
return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerRemoved().processReceipt(tx_receipt)
def add_signer(self, account: str) -> None:
"""
Implementation of add_signer in contract BSend
Method of the function
"""
return self._fn_add_signer.block_send(account, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def bulk_send_token(self, token_addr: str, addresses: List[str], amounts: List[int], wei: int = 0) -> bool:
"""
Implementation of bulk_send_token in contract BSend
Method of the function
"""
return self._fn_bulk_send_token.block_send(token_addr, addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def bulk_send_trx(self, addresses: List[str], amounts: List[int], wei: int = 0) -> bool:
"""
Implementation of bulk_send_trx in contract BSend
Method of the function
"""
return self._fn_bulk_send_trx.block_send(addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def deposit(self, wei: int = 0) -> bool:
"""
Implementation of deposit in contract BSend
Method of the function
"""
return self._fn_deposit.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def eth_send_fee(self) -> int:
"""
Implementation of eth_send_fee in contract BSend
Method of the function
"""
return self._fn_eth_send_fee.block_call()
def get_balance(self, addr: str) -> int:
"""
Implementation of get_balance in contract BSend
Method of the function
"""
return self._fn_get_balance.block_call(addr)
def is_signer(self, account: str) -> bool:
"""
Implementation of is_signer in contract BSend
Method of the function
"""
return self._fn_is_signer.block_call(account)
def renounce_signer(self) -> None:
"""
Implementation of renounce_signer in contract BSend
Method of the function
"""
return self._fn_renounce_signer.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def set_eth_fee(self, eth_send_fee: int) -> bool:
"""
Implementation of set_eth_fee in contract BSend
Method of the function
"""
return self._fn_set_eth_fee.block_send(eth_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def set_token_fee(self, token_send_fee: int) -> bool:
"""
Implementation of set_token_fee in contract BSend
Method of the function
"""
return self._fn_set_token_fee.block_send(token_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def token_send_fee(self) -> int:
"""
Implementation of token_send_fee in contract BSend
Method of the function
"""
return self._fn_token_send_fee.block_call()
def withdraw_ether(self, addr: str, amount: int) -> bool:
"""
Implementation of withdraw_ether in contract BSend
Method of the function
"""
return self._fn_withdraw_ether.block_send(addr, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def withdraw_token(self, token_addr: str, to: str, amount: int) -> bool:
"""
Implementation of withdraw_token in contract BSend
Method of the function
"""
return self._fn_withdraw_token.block_send(token_addr, to, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def CallContractWait(self, t_long: int) -> "BSend":
self._fn_add_signer.setWait(t_long)
self._fn_bulk_send_token.setWait(t_long)
self._fn_bulk_send_trx.setWait(t_long)
self._fn_deposit.setWait(t_long)
self._fn_eth_send_fee.setWait(t_long)
self._fn_get_balance.setWait(t_long)
self._fn_is_signer.setWait(t_long)
self._fn_renounce_signer.setWait(t_long)
self._fn_set_eth_fee.setWait(t_long)
self._fn_set_token_fee.setWait(t_long)
self._fn_token_send_fee.setWait(t_long)
self._fn_withdraw_ether.setWait(t_long)
self._fn_withdraw_token.setWait(t_long)
return self
@staticmethod
def abi():
"""Return the ABI to the underlying contract."""
return json.loads(
'[{"inputs":[],"payable":true,"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerRemoved","type":"event"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendTrx","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"ethSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_ethSendFee","type":"uint256"}],"name":"setEthFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_tokenSendFee","type":"uint256"}],"name":"setTokenFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"tokenSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEther","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]'
# noqa: E501 (line-too-long)
)
# pylint: disable=too-many-lines
Sub-modules
moody.m.b_send.basec
moody.m.b_send.looper
Classes
class AddSignerMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the addSigner method.
Persist instance data.
Expand source code
class AddSignerMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the addSigner method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("addSigner") def validate_and_normalize_inputs(self, account: str) -> any: """Validate the inputs to the addSigner method.""" self.validator.assert_valid( method_name='addSigner', parameter_name='account', argument_value=account, ) account = self.validate_and_checksum_address(account) return (account) def block_send(self, account: str, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(account) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: add_signer") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).transact(tx_params.as_dict()) def build_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).buildTransaction(tx_params.as_dict()) def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, account: str, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> NoneType
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, account: str, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(account) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: add_signer") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).buildTransaction(tx_params.as_dict())
def estimate_gas(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).estimateGas(tx_params.as_dict())
def send_transaction(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, account: str, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, account: str) ‑>
-
Validate the inputs to the addSigner method.
Expand source code
def validate_and_normalize_inputs(self, account: str) -> any: """Validate the inputs to the addSigner method.""" self.validator.assert_valid( method_name='addSigner', parameter_name='account', argument_value=account, ) account = self.validate_and_checksum_address(account) return (account)
Inherited members
class BSend (core_lib: MiliDoS, contract_address: str, validator: BSendValidator = None)
-
Wrapper class for BSend Solidity contract.
Get an instance of wrapper for smart contract.
Expand source code
class BSend(ContractBase): """Wrapper class for BSend Solidity contract.""" _fn_add_signer: AddSignerMethod """Constructor-initialized instance of :class:`AddSignerMethod`. """ _fn_bulk_send_token: BulkSendTokenMethod """Constructor-initialized instance of :class:`BulkSendTokenMethod`. """ _fn_bulk_send_trx: BulkSendTrxMethod """Constructor-initialized instance of :class:`BulkSendTrxMethod`. """ _fn_deposit: DepositMethod """Constructor-initialized instance of :class:`DepositMethod`. """ _fn_eth_send_fee: EthSendFeeMethod """Constructor-initialized instance of :class:`EthSendFeeMethod`. """ _fn_get_balance: GetBalanceMethod """Constructor-initialized instance of :class:`GetBalanceMethod`. """ _fn_is_signer: IsSignerMethod """Constructor-initialized instance of :class:`IsSignerMethod`. """ _fn_renounce_signer: RenounceSignerMethod """Constructor-initialized instance of :class:`RenounceSignerMethod`. """ _fn_set_eth_fee: SetEthFeeMethod """Constructor-initialized instance of :class:`SetEthFeeMethod`. """ _fn_set_token_fee: SetTokenFeeMethod """Constructor-initialized instance of :class:`SetTokenFeeMethod`. """ _fn_token_send_fee: TokenSendFeeMethod """Constructor-initialized instance of :class:`TokenSendFeeMethod`. """ _fn_withdraw_ether: WithdrawEtherMethod """Constructor-initialized instance of :class:`WithdrawEtherMethod`. """ _fn_withdraw_token: WithdrawTokenMethod """Constructor-initialized instance of :class:`WithdrawTokenMethod`. """ SIGNATURES: SignatureGenerator = None def __init__( self, core_lib: MiliDoS, contract_address: str, validator: BSendValidator = None, ): """Get an instance of wrapper for smart contract. """ # pylint: disable=too-many-statements super().__init__() self.contract_address = contract_address web3 = core_lib.w3 if not validator: validator = BSendValidator(web3, contract_address) # if any middleware was imported, inject it try: MIDDLEWARE except NameError: pass else: try: for middleware in MIDDLEWARE: web3.middleware_onion.inject( middleware['function'], layer=middleware['layer'], ) except ValueError as value_error: if value_error.args == ("You can't add the same un-named instance twice",): pass self._web3_eth = web3.eth functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=BSend.abi()).functions signed = SignatureGenerator(BSend.abi()) validator.bindSignatures(signed) self.SIGNATURES = signed self._fn_add_signer = AddSignerMethod(core_lib, contract_address, functions.addSigner, validator) self._fn_bulk_send_token = BulkSendTokenMethod(core_lib, contract_address, functions.bulkSendToken, validator) self._fn_bulk_send_trx = BulkSendTrxMethod(core_lib, contract_address, functions.bulkSendTrx, validator) self._fn_deposit = DepositMethod(core_lib, contract_address, functions.deposit, validator) self._fn_eth_send_fee = EthSendFeeMethod(core_lib, contract_address, functions.ethSendFee, validator) self._fn_get_balance = GetBalanceMethod(core_lib, contract_address, functions.getBalance, validator) self._fn_is_signer = IsSignerMethod(core_lib, contract_address, functions.isSigner, validator) self._fn_renounce_signer = RenounceSignerMethod(core_lib, contract_address, functions.renounceSigner, validator) self._fn_set_eth_fee = SetEthFeeMethod(core_lib, contract_address, functions.setEthFee, validator) self._fn_set_token_fee = SetTokenFeeMethod(core_lib, contract_address, functions.setTokenFee, validator) self._fn_token_send_fee = TokenSendFeeMethod(core_lib, contract_address, functions.tokenSendFee, validator) self._fn_withdraw_ether = WithdrawEtherMethod(core_lib, contract_address, functions.withdrawEther, validator) self._fn_withdraw_token = WithdrawTokenMethod(core_lib, contract_address, functions.withdrawToken, validator) def event_signer_added( self, tx_hash: Union[HexBytes, bytes] ) -> Tuple[AttributeDict]: """ Implementation of event signer_added in contract BSend Get log entry for SignerAdded event. :param tx_hash: hash of transaction emitting SignerAdded event """ tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerAdded().processReceipt(tx_receipt) def event_signer_removed( self, tx_hash: Union[HexBytes, bytes] ) -> Tuple[AttributeDict]: """ Implementation of event signer_removed in contract BSend Get log entry for SignerRemoved event. :param tx_hash: hash of transaction emitting SignerRemoved event """ tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerRemoved().processReceipt(tx_receipt) def add_signer(self, account: str) -> None: """ Implementation of add_signer in contract BSend Method of the function """ return self._fn_add_signer.block_send(account, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def bulk_send_token(self, token_addr: str, addresses: List[str], amounts: List[int], wei: int = 0) -> bool: """ Implementation of bulk_send_token in contract BSend Method of the function """ return self._fn_bulk_send_token.block_send(token_addr, addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def bulk_send_trx(self, addresses: List[str], amounts: List[int], wei: int = 0) -> bool: """ Implementation of bulk_send_trx in contract BSend Method of the function """ return self._fn_bulk_send_trx.block_send(addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def deposit(self, wei: int = 0) -> bool: """ Implementation of deposit in contract BSend Method of the function """ return self._fn_deposit.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def eth_send_fee(self) -> int: """ Implementation of eth_send_fee in contract BSend Method of the function """ return self._fn_eth_send_fee.block_call() def get_balance(self, addr: str) -> int: """ Implementation of get_balance in contract BSend Method of the function """ return self._fn_get_balance.block_call(addr) def is_signer(self, account: str) -> bool: """ Implementation of is_signer in contract BSend Method of the function """ return self._fn_is_signer.block_call(account) def renounce_signer(self) -> None: """ Implementation of renounce_signer in contract BSend Method of the function """ return self._fn_renounce_signer.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def set_eth_fee(self, eth_send_fee: int) -> bool: """ Implementation of set_eth_fee in contract BSend Method of the function """ return self._fn_set_eth_fee.block_send(eth_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def set_token_fee(self, token_send_fee: int) -> bool: """ Implementation of set_token_fee in contract BSend Method of the function """ return self._fn_set_token_fee.block_send(token_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def token_send_fee(self) -> int: """ Implementation of token_send_fee in contract BSend Method of the function """ return self._fn_token_send_fee.block_call() def withdraw_ether(self, addr: str, amount: int) -> bool: """ Implementation of withdraw_ether in contract BSend Method of the function """ return self._fn_withdraw_ether.block_send(addr, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def withdraw_token(self, token_addr: str, to: str, amount: int) -> bool: """ Implementation of withdraw_token in contract BSend Method of the function """ return self._fn_withdraw_token.block_send(token_addr, to, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt) def CallContractWait(self, t_long: int) -> "BSend": self._fn_add_signer.setWait(t_long) self._fn_bulk_send_token.setWait(t_long) self._fn_bulk_send_trx.setWait(t_long) self._fn_deposit.setWait(t_long) self._fn_eth_send_fee.setWait(t_long) self._fn_get_balance.setWait(t_long) self._fn_is_signer.setWait(t_long) self._fn_renounce_signer.setWait(t_long) self._fn_set_eth_fee.setWait(t_long) self._fn_set_token_fee.setWait(t_long) self._fn_token_send_fee.setWait(t_long) self._fn_withdraw_ether.setWait(t_long) self._fn_withdraw_token.setWait(t_long) return self @staticmethod def abi(): """Return the ABI to the underlying contract.""" return json.loads( '[{"inputs":[],"payable":true,"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerRemoved","type":"event"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendTrx","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"ethSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_ethSendFee","type":"uint256"}],"name":"setEthFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_tokenSendFee","type":"uint256"}],"name":"setTokenFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"tokenSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEther","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]' # noqa: E501 (line-too-long) )
Ancestors
Class variables
var SIGNATURES : SignatureGenerator
Static methods
def abi()
-
Return the ABI to the underlying contract.
Expand source code
@staticmethod def abi(): """Return the ABI to the underlying contract.""" return json.loads( '[{"inputs":[],"payable":true,"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"SignerRemoved","type":"event"},{"constant":false,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"bulkSendTrx","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"ethSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceSigner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_ethSendFee","type":"uint256"}],"name":"setEthFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_tokenSendFee","type":"uint256"}],"name":"setTokenFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"tokenSendFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEther","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]' # noqa: E501 (line-too-long) )
Methods
def CallContractWait(self, t_long: int) ‑> BSend
-
Expand source code
def CallContractWait(self, t_long: int) -> "BSend": self._fn_add_signer.setWait(t_long) self._fn_bulk_send_token.setWait(t_long) self._fn_bulk_send_trx.setWait(t_long) self._fn_deposit.setWait(t_long) self._fn_eth_send_fee.setWait(t_long) self._fn_get_balance.setWait(t_long) self._fn_is_signer.setWait(t_long) self._fn_renounce_signer.setWait(t_long) self._fn_set_eth_fee.setWait(t_long) self._fn_set_token_fee.setWait(t_long) self._fn_token_send_fee.setWait(t_long) self._fn_withdraw_ether.setWait(t_long) self._fn_withdraw_token.setWait(t_long) return self
def add_signer(self, account: str) ‑> NoneType
-
Implementation of add_signer in contract BSend Method of the function
Expand source code
def add_signer(self, account: str) -> None: """ Implementation of add_signer in contract BSend Method of the function """ return self._fn_add_signer.block_send(account, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def bulk_send_token(self, token_addr: str, addresses: List[str], amounts: List[int], wei: int = 0) ‑> bool
-
Implementation of bulk_send_token in contract BSend Method of the function
Expand source code
def bulk_send_token(self, token_addr: str, addresses: List[str], amounts: List[int], wei: int = 0) -> bool: """ Implementation of bulk_send_token in contract BSend Method of the function """ return self._fn_bulk_send_token.block_send(token_addr, addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def bulk_send_trx(self, addresses: List[str], amounts: List[int], wei: int = 0) ‑> bool
-
Implementation of bulk_send_trx in contract BSend Method of the function
Expand source code
def bulk_send_trx(self, addresses: List[str], amounts: List[int], wei: int = 0) -> bool: """ Implementation of bulk_send_trx in contract BSend Method of the function """ return self._fn_bulk_send_trx.block_send(addresses, amounts, self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def deposit(self, wei: int = 0) ‑> bool
-
Implementation of deposit in contract BSend Method of the function
Expand source code
def deposit(self, wei: int = 0) -> bool: """ Implementation of deposit in contract BSend Method of the function """ return self._fn_deposit.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, wei, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def eth_send_fee(self) ‑> int
-
Implementation of eth_send_fee in contract BSend Method of the function
Expand source code
def eth_send_fee(self) -> int: """ Implementation of eth_send_fee in contract BSend Method of the function """ return self._fn_eth_send_fee.block_call()
def event_signer_added(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]
-
Implementation of event signer_added in contract BSend Get log entry for SignerAdded event. :param tx_hash: hash of transaction emitting SignerAdded event
Expand source code
def event_signer_added( self, tx_hash: Union[HexBytes, bytes] ) -> Tuple[AttributeDict]: """ Implementation of event signer_added in contract BSend Get log entry for SignerAdded event. :param tx_hash: hash of transaction emitting SignerAdded event """ tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerAdded().processReceipt(tx_receipt)
def event_signer_removed(self, tx_hash: Union[hexbytes.main.HexBytes, bytes]) ‑> Tuple[web3.datastructures.AttributeDict]
-
Implementation of event signer_removed in contract BSend Get log entry for SignerRemoved event. :param tx_hash: hash of transaction emitting SignerRemoved event
Expand source code
def event_signer_removed( self, tx_hash: Union[HexBytes, bytes] ) -> Tuple[AttributeDict]: """ Implementation of event signer_removed in contract BSend Get log entry for SignerRemoved event. :param tx_hash: hash of transaction emitting SignerRemoved event """ tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) return self._web3_eth.contract(address=to_checksum_address(self.contract_address), abi=BSend.abi()).events.SignerRemoved().processReceipt(tx_receipt)
def get_balance(self, addr: str) ‑> int
-
Implementation of get_balance in contract BSend Method of the function
Expand source code
def get_balance(self, addr: str) -> int: """ Implementation of get_balance in contract BSend Method of the function """ return self._fn_get_balance.block_call(addr)
def is_signer(self, account: str) ‑> bool
-
Implementation of is_signer in contract BSend Method of the function
Expand source code
def is_signer(self, account: str) -> bool: """ Implementation of is_signer in contract BSend Method of the function """ return self._fn_is_signer.block_call(account)
def renounce_signer(self) ‑> NoneType
-
Implementation of renounce_signer in contract BSend Method of the function
Expand source code
def renounce_signer(self) -> None: """ Implementation of renounce_signer in contract BSend Method of the function """ return self._fn_renounce_signer.block_send(self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def set_eth_fee(self, eth_send_fee: int) ‑> bool
-
Implementation of set_eth_fee in contract BSend Method of the function
Expand source code
def set_eth_fee(self, eth_send_fee: int) -> bool: """ Implementation of set_eth_fee in contract BSend Method of the function """ return self._fn_set_eth_fee.block_send(eth_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def set_token_fee(self, token_send_fee: int) ‑> bool
-
Implementation of set_token_fee in contract BSend Method of the function
Expand source code
def set_token_fee(self, token_send_fee: int) -> bool: """ Implementation of set_token_fee in contract BSend Method of the function """ return self._fn_set_token_fee.block_send(token_send_fee, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def token_send_fee(self) ‑> int
-
Implementation of token_send_fee in contract BSend Method of the function
Expand source code
def token_send_fee(self) -> int: """ Implementation of token_send_fee in contract BSend Method of the function """ return self._fn_token_send_fee.block_call()
def withdraw_ether(self, addr: str, amount: int) ‑> bool
-
Implementation of withdraw_ether in contract BSend Method of the function
Expand source code
def withdraw_ether(self, addr: str, amount: int) -> bool: """ Implementation of withdraw_ether in contract BSend Method of the function """ return self._fn_withdraw_ether.block_send(addr, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
def withdraw_token(self, token_addr: str, to: str, amount: int) ‑> bool
-
Implementation of withdraw_token in contract BSend Method of the function
Expand source code
def withdraw_token(self, token_addr: str, to: str, amount: int) -> bool: """ Implementation of withdraw_token in contract BSend Method of the function """ return self._fn_withdraw_token.block_send(token_addr, to, amount, self.call_contract_fee_amount, self.call_contract_fee_price, 0, self.call_contract_debug_flag, self.call_contract_enforce_tx_receipt)
class BSendValidator (web3_or_provider: web3.main.Web3, contract_address: str)
-
No-op input validator.
Initialize the instance.
Expand source code
class BSendValidator( # type: ignore Validator ): """No-op input validator."""
Ancestors
Inherited members
class BulkSendTokenMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the bulkSendToken method.
Persist instance data.
Expand source code
class BulkSendTokenMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the bulkSendToken method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("bulkSendToken") def validate_and_normalize_inputs(self, token_addr: str, addresses: List[str], amounts: List[int]) -> any: """Validate the inputs to the bulkSendToken method.""" self.validator.assert_valid( method_name='bulkSendToken', parameter_name='tokenAddr', argument_value=token_addr, ) token_addr = self.validate_and_checksum_address(token_addr) self.validator.assert_valid( method_name='bulkSendToken', parameter_name='addresses', argument_value=addresses, ) self.validator.assert_valid( method_name='bulkSendToken', parameter_name='amounts', argument_value=amounts, ) return (token_addr, addresses, amounts) def block_send(self, token_addr: str, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_addr, addresses, amounts) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_token") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).transact(tx_params.as_dict()) def build_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).buildTransaction(tx_params.as_dict()) def estimate_gas(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, token_addr: str, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, token_addr: str, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_addr, addresses, amounts) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_token") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).estimateGas(tx_params.as_dict())
def send_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, token_addr: str, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_addr, addresses, amounts) = self.validate_and_normalize_inputs(token_addr, addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, addresses, amounts).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, token_addr: str, addresses: List[str], amounts: List[int]) ‑>
-
Validate the inputs to the bulkSendToken method.
Expand source code
def validate_and_normalize_inputs(self, token_addr: str, addresses: List[str], amounts: List[int]) -> any: """Validate the inputs to the bulkSendToken method.""" self.validator.assert_valid( method_name='bulkSendToken', parameter_name='tokenAddr', argument_value=token_addr, ) token_addr = self.validate_and_checksum_address(token_addr) self.validator.assert_valid( method_name='bulkSendToken', parameter_name='addresses', argument_value=addresses, ) self.validator.assert_valid( method_name='bulkSendToken', parameter_name='amounts', argument_value=amounts, ) return (token_addr, addresses, amounts)
Inherited members
class BulkSendTrxMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the bulkSendTrx method.
Persist instance data.
Expand source code
class BulkSendTrxMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the bulkSendTrx method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("bulkSendTrx") def validate_and_normalize_inputs(self, addresses: List[str], amounts: List[int]) -> any: """Validate the inputs to the bulkSendTrx method.""" self.validator.assert_valid( method_name='bulkSendTrx', parameter_name='addresses', argument_value=addresses, ) self.validator.assert_valid( method_name='bulkSendTrx', parameter_name='amounts', argument_value=amounts, ) return (addresses, amounts) def block_send(self, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(addresses, amounts) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_trx") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).transact(tx_params.as_dict()) def build_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).buildTransaction(tx_params.as_dict()) def estimate_gas(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, addresses: List[str], amounts: List[int], gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(addresses, amounts) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: bulk_send_trx") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).buildTransaction(tx_params.as_dict())
def estimate_gas(self, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).estimateGas(tx_params.as_dict())
def send_transaction(self, addresses: List[str], amounts: List[int], tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, addresses: List[str], amounts: List[int], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (addresses, amounts) = self.validate_and_normalize_inputs(addresses, amounts) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addresses, amounts).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, addresses: List[str], amounts: List[int]) ‑>
-
Validate the inputs to the bulkSendTrx method.
Expand source code
def validate_and_normalize_inputs(self, addresses: List[str], amounts: List[int]) -> any: """Validate the inputs to the bulkSendTrx method.""" self.validator.assert_valid( method_name='bulkSendTrx', parameter_name='addresses', argument_value=addresses, ) self.validator.assert_valid( method_name='bulkSendTrx', parameter_name='amounts', argument_value=amounts, ) return (addresses, amounts)
Inherited members
class DepositMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the deposit method.
Persist instance data.
Expand source code
class DepositMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the deposit method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address) self._underlying_method = contract_function self.sign = validator.getSignature("deposit") def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method() try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: deposit") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().transact(tx_params.as_dict()) def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().buildTransaction(tx_params.as_dict()) def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method() try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: deposit") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().buildTransaction(tx_params.as_dict())
def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
def send_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().transact(tx_params.as_dict())
Inherited members
class EthSendFeeMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the ethSendFee method.
Persist instance data.
Expand source code
class EthSendFeeMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the ethSendFee method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address) self._underlying_method = contract_function self.sign = validator.getSignature("ethSendFee") def block_call(self, debug: bool = False) -> int: _fn = self._underlying_method() returned = _fn.call({ 'from': self._operate }) return int(returned) def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_call(self, debug: bool = False) ‑> int
-
Expand source code
def block_call(self, debug: bool = False) -> int: _fn = self._underlying_method() returned = _fn.call({ 'from': self._operate }) return int(returned)
def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Inherited members
class GetBalanceMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the getBalance method.
Persist instance data.
Expand source code
class GetBalanceMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the getBalance method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("getBalance") def validate_and_normalize_inputs(self, addr: str) -> any: """Validate the inputs to the getBalance method.""" self.validator.assert_valid( method_name='getBalance', parameter_name='addr', argument_value=addr, ) addr = self.validate_and_checksum_address(addr) return (addr) def block_call(self, addr: str, debug: bool = False) -> int: _fn = self._underlying_method(addr) returned = _fn.call({ 'from': self._operate }) return int(returned) def estimate_gas(self, addr: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addr) = self.validate_and_normalize_inputs(addr) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_call(self, addr: str, debug: bool = False) ‑> int
-
Expand source code
def block_call(self, addr: str, debug: bool = False) -> int: _fn = self._underlying_method(addr) returned = _fn.call({ 'from': self._operate }) return int(returned)
def estimate_gas(self, addr: str, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, addr: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addr) = self.validate_and_normalize_inputs(addr) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr).estimateGas(tx_params.as_dict())
def validate_and_normalize_inputs(self, addr: str) ‑>
-
Validate the inputs to the getBalance method.
Expand source code
def validate_and_normalize_inputs(self, addr: str) -> any: """Validate the inputs to the getBalance method.""" self.validator.assert_valid( method_name='getBalance', parameter_name='addr', argument_value=addr, ) addr = self.validate_and_checksum_address(addr) return (addr)
Inherited members
class IsSignerMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the isSigner method.
Persist instance data.
Expand source code
class IsSignerMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the isSigner method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("isSigner") def validate_and_normalize_inputs(self, account: str) -> any: """Validate the inputs to the isSigner method.""" self.validator.assert_valid( method_name='isSigner', parameter_name='account', argument_value=account, ) account = self.validate_and_checksum_address(account) return (account) def block_call(self, account: str, debug: bool = False) -> bool: _fn = self._underlying_method(account) returned = _fn.call({ 'from': self._operate }) return bool(returned) def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_call(self, account: str, debug: bool = False) ‑> bool
-
Expand source code
def block_call(self, account: str, debug: bool = False) -> bool: _fn = self._underlying_method(account) returned = _fn.call({ 'from': self._operate }) return bool(returned)
def estimate_gas(self, account: str, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, account: str, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (account) = self.validate_and_normalize_inputs(account) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(account).estimateGas(tx_params.as_dict())
def validate_and_normalize_inputs(self, account: str) ‑>
-
Validate the inputs to the isSigner method.
Expand source code
def validate_and_normalize_inputs(self, account: str) -> any: """Validate the inputs to the isSigner method.""" self.validator.assert_valid( method_name='isSigner', parameter_name='account', argument_value=account, ) account = self.validate_and_checksum_address(account) return (account)
Inherited members
class RenounceSignerMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the renounceSigner method.
Persist instance data.
Expand source code
class RenounceSignerMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the renounceSigner method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address) self._underlying_method = contract_function self.sign = validator.getSignature("renounceSigner") def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method() try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: renounce_signer") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().transact(tx_params.as_dict()) def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().buildTransaction(tx_params.as_dict()) def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> NoneType
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> None: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method() try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: renounce_signer") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().buildTransaction(tx_params.as_dict())
def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
def send_transaction(self, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().transact(tx_params.as_dict())
Inherited members
class SetEthFeeMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the setEthFee method.
Persist instance data.
Expand source code
class SetEthFeeMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the setEthFee method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("setEthFee") def validate_and_normalize_inputs(self, eth_send_fee: int) -> any: """Validate the inputs to the setEthFee method.""" self.validator.assert_valid( method_name='setEthFee', parameter_name='_ethSendFee', argument_value=eth_send_fee, ) # safeguard against fractional inputs eth_send_fee = int(eth_send_fee) return (eth_send_fee) def block_send(self, eth_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(eth_send_fee) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_eth_fee") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).transact(tx_params.as_dict()) def build_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).buildTransaction(tx_params.as_dict()) def estimate_gas(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, eth_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, eth_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(eth_send_fee) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_eth_fee") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, eth_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).buildTransaction(tx_params.as_dict())
def estimate_gas(self, eth_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).estimateGas(tx_params.as_dict())
def send_transaction(self, eth_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, eth_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (eth_send_fee) = self.validate_and_normalize_inputs(eth_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(eth_send_fee).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, eth_send_fee: int) ‑>
-
Validate the inputs to the setEthFee method.
Expand source code
def validate_and_normalize_inputs(self, eth_send_fee: int) -> any: """Validate the inputs to the setEthFee method.""" self.validator.assert_valid( method_name='setEthFee', parameter_name='_ethSendFee', argument_value=eth_send_fee, ) # safeguard against fractional inputs eth_send_fee = int(eth_send_fee) return (eth_send_fee)
Inherited members
class SetTokenFeeMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the setTokenFee method.
Persist instance data.
Expand source code
class SetTokenFeeMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the setTokenFee method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("setTokenFee") def validate_and_normalize_inputs(self, token_send_fee: int) -> any: """Validate the inputs to the setTokenFee method.""" self.validator.assert_valid( method_name='setTokenFee', parameter_name='_tokenSendFee', argument_value=token_send_fee, ) # safeguard against fractional inputs token_send_fee = int(token_send_fee) return (token_send_fee) def block_send(self, token_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_send_fee) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_token_fee") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).transact(tx_params.as_dict()) def build_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).buildTransaction(tx_params.as_dict()) def estimate_gas(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, token_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, token_send_fee: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_send_fee) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: set_token_fee") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, token_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).estimateGas(tx_params.as_dict())
def send_transaction(self, token_send_fee: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, token_send_fee: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_send_fee) = self.validate_and_normalize_inputs(token_send_fee) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_send_fee).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, token_send_fee: int) ‑>
-
Validate the inputs to the setTokenFee method.
Expand source code
def validate_and_normalize_inputs(self, token_send_fee: int) -> any: """Validate the inputs to the setTokenFee method.""" self.validator.assert_valid( method_name='setTokenFee', parameter_name='_tokenSendFee', argument_value=token_send_fee, ) # safeguard against fractional inputs token_send_fee = int(token_send_fee) return (token_send_fee)
Inherited members
class SignatureGenerator (abi:
) -
The signature is generated for this and it is installed.
Expand source code
class SignatureGenerator(Signatures): """ The signature is generated for this and it is installed. """ def __init__(self, abi: any): super().__init__(abi) def add_signer(self) -> str: return self._function_signatures["addSigner"] def bulk_send_token(self) -> str: return self._function_signatures["bulkSendToken"] def bulk_send_trx(self) -> str: return self._function_signatures["bulkSendTrx"] def deposit(self) -> str: return self._function_signatures["deposit"] def eth_send_fee(self) -> str: return self._function_signatures["ethSendFee"] def get_balance(self) -> str: return self._function_signatures["getBalance"] def is_signer(self) -> str: return self._function_signatures["isSigner"] def renounce_signer(self) -> str: return self._function_signatures["renounceSigner"] def set_eth_fee(self) -> str: return self._function_signatures["setEthFee"] def set_token_fee(self) -> str: return self._function_signatures["setTokenFee"] def token_send_fee(self) -> str: return self._function_signatures["tokenSendFee"] def withdraw_ether(self) -> str: return self._function_signatures["withdrawEther"] def withdraw_token(self) -> str: return self._function_signatures["withdrawToken"]
Ancestors
Methods
def add_signer(self) ‑> str
-
Expand source code
def add_signer(self) -> str: return self._function_signatures["addSigner"]
def bulk_send_token(self) ‑> str
-
Expand source code
def bulk_send_token(self) -> str: return self._function_signatures["bulkSendToken"]
def bulk_send_trx(self) ‑> str
-
Expand source code
def bulk_send_trx(self) -> str: return self._function_signatures["bulkSendTrx"]
def deposit(self) ‑> str
-
Expand source code
def deposit(self) -> str: return self._function_signatures["deposit"]
def eth_send_fee(self) ‑> str
-
Expand source code
def eth_send_fee(self) -> str: return self._function_signatures["ethSendFee"]
def get_balance(self) ‑> str
-
Expand source code
def get_balance(self) -> str: return self._function_signatures["getBalance"]
def is_signer(self) ‑> str
-
Expand source code
def is_signer(self) -> str: return self._function_signatures["isSigner"]
def renounce_signer(self) ‑> str
-
Expand source code
def renounce_signer(self) -> str: return self._function_signatures["renounceSigner"]
def set_eth_fee(self) ‑> str
-
Expand source code
def set_eth_fee(self) -> str: return self._function_signatures["setEthFee"]
def set_token_fee(self) ‑> str
-
Expand source code
def set_token_fee(self) -> str: return self._function_signatures["setTokenFee"]
def token_send_fee(self) ‑> str
-
Expand source code
def token_send_fee(self) -> str: return self._function_signatures["tokenSendFee"]
def withdraw_ether(self) ‑> str
-
Expand source code
def withdraw_ether(self) -> str: return self._function_signatures["withdrawEther"]
def withdraw_token(self) ‑> str
-
Expand source code
def withdraw_token(self) -> str: return self._function_signatures["withdrawToken"]
class TokenSendFeeMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the tokenSendFee method.
Persist instance data.
Expand source code
class TokenSendFeeMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the tokenSendFee method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address) self._underlying_method = contract_function self.sign = validator.getSignature("tokenSendFee") def block_call(self, debug: bool = False) -> int: _fn = self._underlying_method() returned = _fn.call({ 'from': self._operate }) return int(returned) def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_call(self, debug: bool = False) ‑> int
-
Expand source code
def block_call(self, debug: bool = False) -> int: _fn = self._underlying_method() returned = _fn.call({ 'from': self._operate }) return int(returned)
def estimate_gas(self, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" tx_params = super().normalize_tx_params(tx_params) return self._underlying_method().estimateGas(tx_params.as_dict())
Inherited members
class WithdrawEtherMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the withdrawEther method.
Persist instance data.
Expand source code
class WithdrawEtherMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the withdrawEther method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("withdrawEther") def validate_and_normalize_inputs(self, addr: str, amount: int) -> any: """Validate the inputs to the withdrawEther method.""" self.validator.assert_valid( method_name='withdrawEther', parameter_name='addr', argument_value=addr, ) addr = self.validate_and_checksum_address(addr) self.validator.assert_valid( method_name='withdrawEther', parameter_name='amount', argument_value=amount, ) # safeguard against fractional inputs amount = int(amount) return (addr, amount) def block_send(self, addr: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(addr, amount) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_ether") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).transact(tx_params.as_dict()) def build_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).buildTransaction(tx_params.as_dict()) def estimate_gas(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, addr: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, addr: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(addr, amount) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_ether") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, addr: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).buildTransaction(tx_params.as_dict())
def estimate_gas(self, addr: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).estimateGas(tx_params.as_dict())
def send_transaction(self, addr: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, addr: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (addr, amount) = self.validate_and_normalize_inputs(addr, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(addr, amount).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, addr: str, amount: int) ‑>
-
Validate the inputs to the withdrawEther method.
Expand source code
def validate_and_normalize_inputs(self, addr: str, amount: int) -> any: """Validate the inputs to the withdrawEther method.""" self.validator.assert_valid( method_name='withdrawEther', parameter_name='addr', argument_value=addr, ) addr = self.validate_and_checksum_address(addr) self.validator.assert_valid( method_name='withdrawEther', parameter_name='amount', argument_value=amount, ) # safeguard against fractional inputs amount = int(amount) return (addr, amount)
Inherited members
class WithdrawTokenMethod (elib: MiliDoS, contract_address: str, contract_function: web3.contract.ContractFunction, validator: Validator = None)
-
Various interfaces to the withdrawToken method.
Persist instance data.
Expand source code
class WithdrawTokenMethod(ContractMethod): # pylint: disable=invalid-name """Various interfaces to the withdrawToken method.""" def __init__(self, elib: MiliDoS, contract_address: str, contract_function: ContractFunction, validator: Validator = None): """Persist instance data.""" super().__init__(elib, contract_address, validator) self._underlying_method = contract_function self.sign = validator.getSignature("withdrawToken") def validate_and_normalize_inputs(self, token_addr: str, to: str, amount: int) -> any: """Validate the inputs to the withdrawToken method.""" self.validator.assert_valid( method_name='withdrawToken', parameter_name='tokenAddr', argument_value=token_addr, ) token_addr = self.validate_and_checksum_address(token_addr) self.validator.assert_valid( method_name='withdrawToken', parameter_name='_to', argument_value=to, ) to = self.validate_and_checksum_address(to) self.validator.assert_valid( method_name='withdrawToken', parameter_name='_amount', argument_value=amount, ) # safeguard against fractional inputs amount = int(amount) return (token_addr, to, amount) def block_send(self, token_addr: str, to: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_addr, to, amount) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_token") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token") def send_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).transact(tx_params.as_dict()) def build_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).buildTransaction(tx_params.as_dict()) def estimate_gas(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).estimateGas(tx_params.as_dict())
Ancestors
Methods
def block_send(self, token_addr: str, to: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) ‑> bool
-
Execute underlying contract method via eth_call.
:param tx_params: transaction parameters :returns: the return value of the underlying method.
Expand source code
def block_send(self, token_addr: str, to: str, amount: int, gas: int, price: int, val: int = 0, debug: bool = False, receiptListen: bool = False) -> bool: """Execute underlying contract method via eth_call. :param tx_params: transaction parameters :returns: the return value of the underlying method. """ _fn = self._underlying_method(token_addr, to, amount) try: _t = _fn.buildTransaction({ 'from': self._operate, 'gas': gas, 'gasPrice': price }) _t['nonce'] = self._web3_eth.getTransactionCount(self._operate) if val > 0: _t['value'] = val if debug: print(f"======== Signing ✅ by {self._operate}") print(f"======== Transaction ✅ check") print(_t) if 'data' in _t: signed = self._web3_eth.account.sign_transaction(_t) txHash = self._web3_eth.sendRawTransaction(signed.rawTransaction) tx_receipt = None if receiptListen is True: print(f"======== awaiting Confirmation 🚸️ {self.sign}") tx_receipt = self._web3_eth.waitForTransactionReceipt(txHash) if debug: print("======== TX Result ✅") print(tx_receipt) print(f"======== TX blockHash ✅") if tx_receipt is not None: print(f"{Bolors.OK}{tx_receipt.blockHash.hex()}{Bolors.RESET}") else: print(f"{Bolors.WARNING}{txHash.hex()}{Bolors.RESET} - broadcast hash") if receiptListen is False: time.sleep(self._wait) except ContractLogicError as er: print(f"{Bolors.FAIL}Error {er} {Bolors.RESET}: withdraw_token") except ValueError as err: if "message" in err.args[0]: message = err.args[0]["message"] print(f"{Bolors.FAIL}Error Revert {Bolors.RESET} on set_asset_token: {message}") else: print(f"{Bolors.FAIL}Error Revert {Bolors.RESET}: set_asset_token")
def build_transaction(self, token_addr: str, to: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> dict
-
Construct calldata to be used as input to the method.
Expand source code
def build_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> dict: """Construct calldata to be used as input to the method.""" (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).buildTransaction(tx_params.as_dict())
def estimate_gas(self, token_addr: str, to: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> int
-
Estimate gas consumption of method call.
Expand source code
def estimate_gas(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> int: """Estimate gas consumption of method call.""" (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).estimateGas(tx_params.as_dict())
def send_transaction(self, token_addr: str, to: str, amount: int, tx_params: Union[TxParams, NoneType] = None) ‑> Union[hexbytes.main.HexBytes, bytes]
-
Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters
Expand source code
def send_transaction(self, token_addr: str, to: str, amount: int, tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]: """Execute underlying contract method via eth_sendTransaction. :param tx_params: transaction parameters """ (token_addr, to, amount) = self.validate_and_normalize_inputs(token_addr, to, amount) tx_params = super().normalize_tx_params(tx_params) return self._underlying_method(token_addr, to, amount).transact(tx_params.as_dict())
def validate_and_normalize_inputs(self, token_addr: str, to: str, amount: int) ‑>
-
Validate the inputs to the withdrawToken method.
Expand source code
def validate_and_normalize_inputs(self, token_addr: str, to: str, amount: int) -> any: """Validate the inputs to the withdrawToken method.""" self.validator.assert_valid( method_name='withdrawToken', parameter_name='tokenAddr', argument_value=token_addr, ) token_addr = self.validate_and_checksum_address(token_addr) self.validator.assert_valid( method_name='withdrawToken', parameter_name='_to', argument_value=to, ) to = self.validate_and_checksum_address(to) self.validator.assert_valid( method_name='withdrawToken', parameter_name='_amount', argument_value=amount, ) # safeguard against fractional inputs amount = int(amount) return (token_addr, to, amount)
Inherited members