def validate_abi_value(abi_type, value):
"""
Helper function for validating a value against the expected abi_type
Note: abi_type 'bytes' must either be python3 'bytes' object or ''
"""
if is_array_type(abi_type) and is_list_like(value):
# validate length
specified_length = length_of_array_type(abi_type)
if specified_length is not None:
if specified_length < 1:
raise TypeError(
"Invalid abi-type: {abi_type}. Length of fixed sized arrays"
"must be greater than 0.".format(abi_type=abi_type))
if specified_length != len(value):
raise TypeError(
"The following array length does not the length specified"
"by the abi-type, {abi_type}: {value}".format(
abi_type=abi_type, value=value))
# validate sub_types
sub_type = sub_type_of_array_type(abi_type)
for v in value:
validate_abi_value(sub_type, v)
return
elif is_bool_type(abi_type) and is_boolean(value):
return
elif is_uint_type(abi_type) and is_integer(value) and value >= 0:
return
elif is_int_type(abi_type) and is_integer(value):
return
elif is_address_type(abi_type):
validate_address(value)
return
elif is_bytes_type(abi_type):
if is_bytes(value):
return
elif is_string(value):
if is_0x_prefixed(value):
return
else:
raise TypeError(
"ABI values of abi-type 'bytes' must be either"
"a python3 'bytes' object or an '0x' prefixed string.")
elif is_string_type(abi_type) and is_string(value):
return
raise TypeError(
"The following abi value is not a '{abi_type}': {value}".format(
abi_type=abi_type, value=value))
def test_eth_syncing(self, web3):
syncing = web3.eth.syncing
assert is_boolean(syncing) or is_dict(syncing)
if is_boolean(syncing):
assert syncing is False
elif is_dict(syncing):
assert 'startingBlock' in syncing
assert 'currentBlock' in syncing
assert 'highestBlock' in syncing
assert is_integer(syncing['startingBlock'])
assert is_integer(syncing['currentBlock'])
assert is_integer(syncing['highestBlock'])
def inject(self, element, name=None, layer=None):
'''
Inject a named element to an arbitrary layer in the onion.
The current implementation only supports insertion at the innermost layer,
or at the outermost layer. Note that inserting to the outermost is equivalent
to calling :meth:`add` .
'''
if not is_integer(layer):
raise TypeError("The layer for insertion must be an int.")
elif layer != 0 and layer != len(self._queue):
raise NotImplementedError(
"You can only insert to the beginning or end of a %s, currently. "
"You tried to insert to %d, but only 0 and %d are permitted. " % (
type(self),
layer,
len(self._queue),
)
)
self.add(element, name=name)
if layer == 0:
if name is None:
name = element
self._queue.move_to_end(name, last=False)
elif layer == len(self._queue):
return
else:
raise AssertionError("Impossible to reach: earlier validation raises an error")
def test_eth_getBlockTransactionCountByNumber_block_with_txn(
self, web3, block_with_txn):
transaction_count = web3.eth.getBlockTransactionCount(
block_with_txn['number'])
assert is_integer(transaction_count)
assert transaction_count >= 1
def test_eth_getBlockTransactionCountByNumber_empty_block(
self, web3, empty_block):
transaction_count = web3.eth.getBlockTransactionCount(
empty_block['number'])
assert is_integer(transaction_count)
assert transaction_count == 0
def test_eth_estimateGas(self, web3, unlocked_account_dual_type):
gas_estimate = web3.eth.estimateGas({
'from': unlocked_account_dual_type,
'to': unlocked_account_dual_type,
'value': 1,
})
assert is_integer(gas_estimate)
assert gas_estimate > 0
def test_eth_getBalance(self, web3):
coinbase = web3.eth.coinbase
with pytest.raises(InvalidAddress):
web3.eth.getBalance(coinbase.lower())
balance = web3.eth.getBalance(coinbase)
assert is_integer(balance)
assert balance >= 0
def test_implicitcontract_call_default(math_contract, get_transaction_count):
# When a function is called that defaults to call
blocknum, starting_txns = get_transaction_count("pending")
start_count = math_contract.counter()
assert is_integer(start_count)
# Check that a call was made and not a transact
# (Auto-mining is enabled, so query by block number)
assert get_transaction_count(blocknum) == starting_txns
# Check that no blocks were mined
assert get_transaction_count("pending") == (blocknum, 0)
def test_implicitcontract_transact_default(web3, math_contract,
get_transaction_count):
# Use to verify correct operation later on
start_count = math_contract.counter()
assert is_integer(start_count) # Verify correct type
# When a function is called that defaults to transact
blocknum, starting_txns = get_transaction_count("pending")
math_contract.increment(transact={})
# Check that a transaction was made and not a call
assert math_contract.counter() - start_count == 1
# (Auto-mining is enabled, so query by block number)
assert get_transaction_count(blocknum) == starting_txns + 1
# Check that only one block was mined
assert get_transaction_count("pending") == (blocknum + 1, 0)
def test_implicitcontract_transact_override(math_contract,
get_transaction_count):
# Use to verify correct operation later on
start_count = math_contract.counter()
assert is_integer(start_count) # Verify correct type
# When a function is called with call override that defaults to transact
blocknum, starting_txns = get_transaction_count("pending")
math_contract.increment(call={})
# Check that a call was made and not a transact
assert math_contract.counter() - start_count == 0
# (Auto-mining is enabled, so query by block number)
assert get_transaction_count(blocknum) == starting_txns
# Check that no blocks were mined
assert get_transaction_count("pending") == (blocknum, 0)
def is_predefined_block_number(value):
if is_text(value):
value_text = value
elif is_bytes(value):
# `value` could either be random bytes or the utf-8 encoding of
# one of the words in: {"latest", "pending", "earliest"}
# We cannot decode the bytes as utf8, because random bytes likely won't be valid.
# So we speculatively decode as 'latin-1', which cannot fail.
value_text = value.decode('latin-1')
elif is_integer(value):
return False
else:
raise TypeError("unrecognized block reference: %r" % value)
return value_text in {"latest", "pending", "earliest"}
def to_text(primitive=None, hexstr=None, text=None):
assert_one_val(primitive, hexstr=hexstr, text=text)
if hexstr is not None:
return to_bytes(hexstr=hexstr).decode('utf-8')
elif text is not None:
return text
elif isinstance(primitive, str):
return to_text(hexstr=primitive)
elif isinstance(primitive, bytes):
return primitive.decode('utf-8')
elif is_integer(primitive):
byte_encoding = int_to_big_endian(primitive)
return to_text(byte_encoding)
raise TypeError("Expected an int, bytes or hexstr.")
def select_method_for_block_identifier(value, if_hash, if_number, if_predefined):
if is_predefined_block_number(value):
return if_predefined
elif isinstance(value, bytes):
return if_hash
elif is_hex_encoded_block_hash(value):
return if_hash
elif is_integer(value) and (0 <= value < 2**256):
return if_number
elif is_hex_encoded_block_number(value):
return if_number
else:
raise ValueError(
"Value did not match any of the recognized block identifiers: {0}".format(value)
)
def to_bytes(primitive=None, hexstr=None, text=None):
assert_one_val(primitive, hexstr=hexstr, text=text)
if is_boolean(primitive):
return b'\x01' if primitive else b'\x00'
elif isinstance(primitive, bytes):
return primitive
elif is_integer(primitive):
return to_bytes(hexstr=to_hex(primitive))
elif hexstr is not None:
if len(hexstr) % 2:
hexstr = '0x0' + remove_0x_prefix(hexstr)
return decode_hex(hexstr)
elif text is not None:
return text.encode('utf-8')
raise TypeError(
"expected an int in first arg, or keyword of hexstr or text")
def _get_block_by_number(method, params, block_info=_block_info):
block_id = params[0]
blocks = block_info['blocks']
head_block_number = block_info['head_block_number']
if block_id == 'latest':
return blocks[head_block_number]
elif block_id == 'pending':
if head_block_number + 1 >= len(blocks):
raise ValueError("no pending block")
return blocks[head_block_number + 1]
elif block_id == 'earliest':
return blocks[0]
elif is_integer(block_id):
if block_id <= head_block_number:
return blocks[block_id]
else:
return None
else:
raise TypeError('Invalid type for block_id')
def test_net_peerCount(self, web3):
peer_count = web3.net.peerCount
assert is_integer(peer_count)
def test_eth_getUncleCountByBlockNumber(self, web3, empty_block):
uncle_count = web3.eth.getUncleCount(empty_block['number'])
assert is_integer(uncle_count)
assert uncle_count == 0
def test_eth_hashrate(self, web3):
hashrate = web3.eth.hashrate
assert is_integer(hashrate)
assert hashrate >= 0
def test_eth_gasPrice(self, web3):
gas_price = web3.eth.gasPrice
assert is_integer(gas_price)
assert gas_price > 0
def test_eth_blockNumber(self, web3):
block_number = web3.eth.blockNumber
assert is_integer(block_number)
assert block_number >= 0
def test_eth_getTransactionCount(self, web3, unlocked_account_dual_type):
transaction_count = web3.eth.getTransactionCount(
unlocked_account_dual_type)
assert is_integer(transaction_count)
assert transaction_count >= 0
def validate_integer(value: Any) -> None:
if not is_integer(value) or isinstance(value, bool):
raise ValidationError("Value must be a an integer. Got: {0}".format(
type(value)))
