def _init_step_cost() -> dict:
raw_step_costs = {
governance.STEP_TYPE_DEFAULT: 4000,
governance.STEP_TYPE_CONTRACT_CALL: 1500,
governance.STEP_TYPE_CONTRACT_CREATE: 20000,
governance.STEP_TYPE_CONTRACT_UPDATE: 8000,
governance.STEP_TYPE_CONTRACT_DESTRUCT: -7000,
governance.STEP_TYPE_CONTRACT_SET: 1000,
governance.STEP_TYPE_GET: 5,
governance.STEP_TYPE_SET: 20,
governance.STEP_TYPE_REPLACE: 5,
governance.STEP_TYPE_DELETE: -15,
governance.STEP_TYPE_INPUT: 20,
governance.STEP_TYPE_EVENT_LOG: 10,
governance.STEP_TYPE_API_CALL: 10000
}
step_costs = {}
for key, value in raw_step_costs.items():
try:
step_costs[StepType(key)] = value
except ValueError:
# Pass the unknown step type
pass
# return IconScoreStepCounter(step_costs, 5000000, 0)
return step_costs
def test_out_of_step(self):
tx_hash = bytes.hex(create_tx_hash())
from_ = create_address(AddressPrefix.EOA)
to_ = create_address(AddressPrefix.CONTRACT)
request = create_request([ReqData(tx_hash, from_, to_, 'call', {})])
# noinspection PyUnusedLocal
def intercept_invoke(*args, **kwargs):
ContextContainer._push_context(args[0])
context_db = self._inner_task._icon_service_engine._icx_context_db
score = SampleScore(IconScoreDatabase(to_, context_db))
score.hash_writable()
score_engine_invoke = Mock(side_effect=intercept_invoke)
self._inner_task._icon_service_engine._validate_score_blacklist = Mock(
)
self._inner_task._icon_service_engine. \
_icon_score_engine.invoke = score_engine_invoke
raw_step_costs = {
governance.STEP_TYPE_DEFAULT: 4000,
governance.STEP_TYPE_CONTRACT_CALL: 1500,
governance.STEP_TYPE_CONTRACT_CREATE: 20000,
governance.STEP_TYPE_CONTRACT_UPDATE: 8000,
governance.STEP_TYPE_CONTRACT_DESTRUCT: -7000,
governance.STEP_TYPE_CONTRACT_SET: 1000,
governance.STEP_TYPE_GET: 5,
governance.STEP_TYPE_SET: 20,
governance.STEP_TYPE_REPLACE: 5,
governance.STEP_TYPE_DELETE: -15,
governance.STEP_TYPE_INPUT: 20,
governance.STEP_TYPE_EVENT_LOG: 10,
governance.STEP_TYPE_API_CALL: 0
}
step_costs = {}
factory = self._inner_task._icon_service_engine._step_counter_factory
for key, value in raw_step_costs.items():
try:
step_costs[StepType(key)] = value
except ValueError:
# Pass the unknown step type
pass
self.step_counter = IconScoreStepCounter(step_costs, 100, 0)
factory.create = Mock(return_value=self.step_counter)
self._inner_task._icon_service_engine._icon_score_mapper.get_icon_score = Mock(
return_value=None)
result = self._inner_task._invoke(request)
self.assertTrue(result['txResults'][tx_hash]['failure']
['message'].startswith("Out of step"))
def test_set_step_costs(self):
governance_score = Mock()
governance_score.getStepCosts = Mock(
return_value={
governance.STEP_TYPE_DEFAULT: 4000,
governance.STEP_TYPE_CONTRACT_CALL: 1500,
governance.STEP_TYPE_CONTRACT_CREATE: 20000,
governance.STEP_TYPE_CONTRACT_UPDATE: 8000,
governance.STEP_TYPE_CONTRACT_DESTRUCT: -7000,
governance.STEP_TYPE_CONTRACT_SET: 1000,
governance.STEP_TYPE_GET: 5,
governance.STEP_TYPE_SET: 20,
governance.STEP_TYPE_REPLACE: 5,
governance.STEP_TYPE_DELETE: -15,
governance.STEP_TYPE_INPUT: 20,
governance.STEP_TYPE_EVENT_LOG: 10
})
step_counter_factory = IconScoreStepCounterFactory()
step_costs = governance_score.getStepCosts()
for key, value in step_costs.items():
try:
step_counter_factory.set_step_cost(StepType(key), value)
except ValueError:
pass
self.assertEqual(4000,
step_counter_factory.get_step_cost(StepType.DEFAULT))
self.assertEqual(
1500, step_counter_factory.get_step_cost(StepType.CONTRACT_CALL))
self.assertEqual(
20000,
step_counter_factory.get_step_cost(StepType.CONTRACT_CREATE))
self.assertEqual(
8000, step_counter_factory.get_step_cost(StepType.CONTRACT_UPDATE))
self.assertEqual(
-7000,
step_counter_factory.get_step_cost(StepType.CONTRACT_DESTRUCT))
self.assertEqual(
1000, step_counter_factory.get_step_cost(StepType.CONTRACT_SET))
self.assertEqual(5, step_counter_factory.get_step_cost(StepType.GET))
self.assertEqual(20, step_counter_factory.get_step_cost(StepType.SET))
self.assertEqual(5,
step_counter_factory.get_step_cost(StepType.REPLACE))
self.assertEqual(-15,
step_counter_factory.get_step_cost(StepType.DELETE))
self.assertEqual(20,
step_counter_factory.get_step_cost(StepType.INPUT))
self.assertEqual(
10, step_counter_factory.get_step_cost(StepType.EVENT_LOG))
def settable_inv_container():
default_service_config: int = 0
default_step_costs = {
'default': 1_000_000,
'contractCall': 15_000,
'contractCreate': 200_000,
'contractUpdate': 80_000,
'contractDestruct': -70_000,
'contractSet': 30_000,
'get': 0,
'set': 200,
'replace': 50,
'delete': -150,
'input': 200,
'eventLog': 100,
'apiCall': 0
}
default_step_costs = {
StepType(key): val
for key, val in default_step_costs.items()
}
default_max_step_limits: dict = {
IconScoreContextType.INVOKE: 2_500_000_000,
IconScoreContextType.QUERY: 50_000_000
}
default_step_price: int = 0
default_score_black_list: list = []
default_import_white_list = {"iconservice": ['*']}
inv_container = INVContainer(is_migrated=False)
inv_container._icon_network_values = {
IconNetworkValueType.REVISION_CODE:
RevisionCode(0),
IconNetworkValueType.SCORE_BLACK_LIST:
ScoreBlackList(default_score_black_list),
IconNetworkValueType.STEP_PRICE:
StepPrice(default_step_price),
IconNetworkValueType.STEP_COSTS:
StepCosts(default_step_costs),
IconNetworkValueType.MAX_STEP_LIMITS:
MaxStepLimits(default_max_step_limits),
IconNetworkValueType.SERVICE_CONFIG:
ServiceConfig(default_service_config),
IconNetworkValueType.IMPORT_WHITE_LIST:
ImportWhiteList(default_import_white_list)
}
return inv_container
def check_inv(self, is_migrated):
# Actual test code
"""Service Config"""
# TEST: service config should be same between icon-service and governance
gs_service_config: dict = self._get_service_config()
is_service_flag: int = self._get_inv_from_is(
IconNetworkValueType.SERVICE_CONFIG)
is_service_config: dict = self._convert_service_config_from_int_to_dict(
is_service_flag)
assert gs_service_config == is_service_config
"""Step Price"""
# TEST: Step price should be same between icon-service and governance
gs_step_price: int = self._get_step_price()
is_step_price = self._get_inv_from_is(IconNetworkValueType.STEP_PRICE)
assert is_step_price == gs_step_price
# TEST: When update the step price, icon service should update accordingly
expected_step_price: int = randint(10, 20)
self._set_step_price(expected_step_price, is_migrated)
gs_step_price: int = self._get_step_price()
is_step_price = self._get_inv_from_is(IconNetworkValueType.STEP_PRICE)
assert is_step_price == gs_step_price == expected_step_price
"""Step Costs"""
# TEST: Step costs should be same between icon-service and governance
gs_step_costs = self._get_step_costs()
is_step_costs = ValueConverter.convert_for_governance(
IconNetworkValueType.STEP_COSTS,
self._get_inv_from_is(IconNetworkValueType.STEP_COSTS))
assert is_step_costs == gs_step_costs
# TEST: When update the step costs, icon service should update accordingly
for step_type in StepType:
type_: str = step_type.value
expected_costs = randint(10, 100)
self._set_step_costs(type_,
expected_costs,
is_migrated=is_migrated)
gs_step_costs = self._get_step_costs()
is_step_costs = self._get_inv_from_is(
IconNetworkValueType.STEP_COSTS)
assert gs_step_costs[type_] == is_step_costs[StepType(
type_)] == expected_costs
"""Max Step Limits"""
# TEST: Max step limits should be same between icon-service and governance
gs_invoke_max_step_limit = self._get_max_step_limit("invoke")
gs_query_max_step_limit = self._get_max_step_limit("query")
is_max_step_limit = self._get_inv_from_is(
IconNetworkValueType.MAX_STEP_LIMITS)
assert is_max_step_limit[
IconScoreContextType.INVOKE] == gs_invoke_max_step_limit
assert is_max_step_limit[
IconScoreContextType.QUERY] == gs_query_max_step_limit
# TEST: When update the max step limits, icon service should update accordingly
invoke_type: str = "invoke"
query_type: str = "query"
expected_invoke_value = randint(2_600_000_000, 2_700_000_000)
expected_query_value = randint(60_000_000, 70_000_000)
self._set_max_step_limit(invoke_type, expected_invoke_value,
is_migrated)
self._set_max_step_limit(query_type, expected_query_value, is_migrated)
gs_invoke_max_step_limit = self._get_max_step_limit("invoke")
gs_query_max_step_limit = self._get_max_step_limit("query")
is_max_step_limit = self._get_inv_from_is(
IconNetworkValueType.MAX_STEP_LIMITS)
assert is_max_step_limit[
IconScoreContextType.
INVOKE] == gs_invoke_max_step_limit == expected_invoke_value
assert is_max_step_limit[
IconScoreContextType.
QUERY] == gs_query_max_step_limit == expected_query_value
"""Revision"""
# TEST: Revision should be same between icon-service and governance
gs_revision = self._get_revision()
is_revision_code = self._get_inv_from_is(
IconNetworkValueType.REVISION_CODE)
is_revision_name = self._get_inv_from_is(
IconNetworkValueType.REVISION_NAME)
assert is_revision_code == gs_revision['code']
assert is_revision_name == gs_revision['name']
# TEST: When update the revision, icon service should update accordingly
expected_revision_value = Revision.IISS.value
expected_revision_name = f"1.1.{Revision.IISS.value}"
self._set_revision(expected_revision_value, is_migrated)
gs_revision = self._get_revision()
is_revision_code = self._get_inv_from_is(
IconNetworkValueType.REVISION_CODE)
is_revision_name = self._get_inv_from_is(
IconNetworkValueType.REVISION_NAME)
assert is_revision_code == gs_revision[
'code'] == expected_revision_value
assert is_revision_name == gs_revision['name'] == expected_revision_name
"""Score Black List"""
# TEST: Score black list should be same between icon-service and governance
expected_is_in_black_list: bool = False
score_address: 'Address' = create_address(AddressPrefix.CONTRACT)
gs_is_in_black_list = self._is_in_score_black_list(score_address)
is_is_in_black_list = score_address in self._get_inv_from_is(
IconNetworkValueType.SCORE_BLACK_LIST)
assert is_is_in_black_list == gs_is_in_black_list == expected_is_in_black_list
# TEST: When update the Score black list, icon service should update accordingly
expected_is_in_black_list: bool = True
self._add_to_score_black_list(score_address, is_migrated)
gs_is_in_black_list = self._is_in_score_black_list(score_address)
is_is_in_black_list = score_address in self._get_inv_from_is(
IconNetworkValueType.SCORE_BLACK_LIST)
assert is_is_in_black_list == gs_is_in_black_list == expected_is_in_black_list
"""Import White List"""
# TEST: Import white list should be same between icon-service and governance
expected_is_in_import_list: bool = False
import_stmt = "{'os': ['path']}"
is_import_list = self._get_inv_from_is(
IconNetworkValueType.IMPORT_WHITE_LIST)
gs_is_in_import_list = self._is_in_import_white_list(import_stmt)
is_is_in_import_list = is_import_list.get('os', None) is not None
assert is_is_in_import_list == gs_is_in_import_list == expected_is_in_import_list
# TEST: When add import white list, icon service should update accordingly
# After governance 0.0.6, adding import white list is removed. So do not test after migration
if not is_migrated:
expected_is_in_import_list: bool = True
self._add_import_white_list(import_stmt, is_migrated)
gs_is_in_import_list = self._is_in_import_white_list(import_stmt)
is_is_in_import_list = \
self._get_inv_from_is(IconNetworkValueType.IMPORT_WHITE_LIST).get('os', None) is not None
assert is_is_in_import_list == gs_is_in_import_list == expected_is_in_import_list
# Remove added import white list (kind of tear down)
self._remove_import_white_list(import_stmt)