def test_tx_failure(self, score_invoke):
score_invoke.side_effect = Mock(
side_effect=InvalidParamsException("error"))
from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20))
tx_index = randrange(0, 100)
self._mock_context.tx = Transaction(os.urandom(32), tx_index, from_,
to_, 0)
self._mock_context.msg = Message(from_)
self._mock_context.tx_batch = TransactionBatch()
raise_exception_start_tag("test_tx_failure")
tx_result = self._icon_service_engine._handle_icx_send_transaction(
self._mock_context, {
'from': from_,
'to': to_
})
raise_exception_end_tag("test_tx_failure")
self._icon_service_engine._charge_transaction_fee.assert_called()
self.assertEqual(0, tx_result.status)
self.assertEqual(tx_index, tx_result.tx_index)
self.assertIsNone(tx_result.score_address)
camel_dict = tx_result.to_dict(to_camel_case)
self.assertNotIn('scoreAddress', camel_dict)
def test_tx_success(self):
from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
to_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
tx_index = randrange(0, 100)
self._mock_context.tx = Transaction(os.urandom(32), tx_index, from_,
to_, 0)
self._mock_context.msg = Message(from_)
params = {
'version': 3,
'from': from_,
'to': to_,
'value': 0,
'timestamp': 1234567890,
'nonce': 1
}
self._icon_service_engine._process_transaction = Mock(
return_value=None)
tx_result = self._icon_service_engine._handle_icx_send_transaction(
self._mock_context, params)
self._icon_service_engine._charge_transaction_fee.assert_called()
self.assertEqual(1, tx_result.status)
self.assertEqual(tx_index, tx_result.tx_index)
self.assertEqual(to_, tx_result.to)
self.assertIsNone(tx_result.score_address)
camel_dict = tx_result.to_dict(to_camel_case)
self.assertNotIn('failure', camel_dict)
self.assertNotIn('scoreAddress', camel_dict)
def test_from_dict_with_transfer_event_log(self):
signature = "Transfer(Address,Address,int)"
score_address = Address.from_string(
"cx4d6f646441a3f9c9b91019c9b98e3c342cceb114"
)
indexed_address_0 = Address.from_data(AddressPrefix.EOA, b"address0")
indexed_address_1 = Address.from_data(AddressPrefix.EOA, b"address1")
value = 0x8AC7230489E80000
event_log_data = {
"scoreAddress": str(score_address),
"indexed": [
signature,
str(indexed_address_0),
str(indexed_address_1),
hex(value),
],
"data": [],
}
event_log = EventLog.from_dict(event_log_data)
assert event_log.signature == signature
assert event_log.score_address == score_address
assert event_log.indexed[0] == signature
assert len(event_log.indexed) == 4
assert event_log.indexed[1] == indexed_address_0
assert event_log.indexed[2] == indexed_address_1
assert event_log.indexed[3] == value
assert len(event_log.data) == 0
def test_sample_result(self):
from_ = Address.from_data(AddressPrefix.EOA, b'from')
to_ = Address.from_data(AddressPrefix.CONTRACT, b'to')
self._mock_context.tx = Transaction(os.urandom(32), 1234, from_, to_,
0)
self._mock_context.msg = Message(from_)
IconScoreContext.engine.deploy.invoke = Mock()
self._icon_service_engine._process_transaction = Mock(return_value=to_)
tx_result = self._icon_service_engine._handle_icx_send_transaction(
self._mock_context, {
'from': from_,
'to': to_
})
tx_result.score_address = to_
tx_result.event_logs = [
EventLog(
Address.from_data(AddressPrefix.CONTRACT, b'addr_to'),
[b'indexed',
Address.from_data(AddressPrefix.EOA, b'index')],
[True, 1234, 'str', None, b'test'])
]
tx_result.logs_bloom = BloomFilter()
tx_result.logs_bloom.add(b'1')
tx_result.logs_bloom.add(b'2')
tx_result.logs_bloom.add(b'3')
tx_result.block = Block(123,
hashlib.sha3_256(b'block').digest(), 1, None,
0)
camel_dict = tx_result.to_dict(to_camel_case)
self.assertIn('txHash', camel_dict)
self.assertIn('blockHeight', camel_dict)
self.assertIn('txIndex', camel_dict)
self.assertIn('to', camel_dict)
self.assertIn('scoreAddress', camel_dict)
self.assertIn('stepUsed', camel_dict)
self.assertIn('stepPrice', camel_dict)
self.assertIn('eventLogs', camel_dict)
self.assertIn('logsBloom', camel_dict)
self.assertIn('status', camel_dict)
self.assertEqual(1, len(camel_dict['eventLogs']))
self.assertIn('scoreAddress', camel_dict['eventLogs'][0])
self.assertIn('indexed', camel_dict['eventLogs'][0])
self.assertIn('data', camel_dict['eventLogs'][0])
self.assertEqual(256, len(camel_dict['logsBloom']))
converted_result = TypeConverter.convert_type_reverse(camel_dict)
self.assertFalse(converted_result['txHash'].startswith('0x'))
self.assertTrue(converted_result['blockHeight'].startswith('0x'))
self.assertTrue(converted_result['txIndex'].startswith('0x'))
self.assertTrue(converted_result['to'].startswith('cx'))
self.assertTrue(converted_result['scoreAddress'].startswith('cx'))
self.assertTrue(converted_result['stepUsed'].startswith('0x'))
self.assertTrue(converted_result['logsBloom'].startswith('0x'))
self.assertTrue(converted_result['status'].startswith('0x'))
def test_sample_result(self):
from_ = Address.from_data(AddressPrefix.EOA, b'from')
to_ = Address.from_data(AddressPrefix.CONTRACT, b'to')
self._mock_context.tx.index = 1234
self._mock_context.tx.hash = hashlib.sha256(b'hash').digest()
self._icon_service_engine._icon_score_deploy_engine.attach_mock(
Mock(return_value=False), 'is_data_type_supported')
tx_result = self._icon_service_engine._handle_icx_send_transaction(
self._mock_context, {'from': from_, 'to': to_})
tx_result.score_address = \
Address.from_data(AddressPrefix.CONTRACT, b'score_address')
tx_result.event_logs = [
EventLog(
Address.from_data(AddressPrefix.CONTRACT, b'addr_to'),
[b'indexed', Address.from_data(AddressPrefix.EOA, b'index')],
[True, 1234, 'str', None, b'test']
)
]
tx_result.logs_bloom = BloomFilter()
tx_result.logs_bloom.add(b'1')
tx_result.logs_bloom.add(b'2')
tx_result.logs_bloom.add(b'3')
tx_result.block = Block(123, hashlib.sha256(b'block').digest(), 1, None)
camel_dict = tx_result.to_dict(to_camel_case)
self.assertIn('txHash', camel_dict)
self.assertIn('blockHeight', camel_dict)
self.assertIn('txIndex', camel_dict)
self.assertIn('to', camel_dict)
self.assertIn('scoreAddress', camel_dict)
self.assertIn('stepUsed', camel_dict)
self.assertIn('stepPrice', camel_dict)
self.assertIn('eventLogs', camel_dict)
self.assertIn('logsBloom', camel_dict)
self.assertIn('status', camel_dict)
self.assertEqual(1, len(camel_dict['eventLogs']))
self.assertIn('scoreAddress', camel_dict['eventLogs'][0])
self.assertIn('indexed', camel_dict['eventLogs'][0])
self.assertIn('data', camel_dict['eventLogs'][0])
self.assertEqual(256, len(camel_dict['logsBloom']))
converted_result = TypeConverter.convert_type_reverse(camel_dict)
self.assertFalse(converted_result['txHash'].startswith('0x'))
self.assertTrue(converted_result['blockHeight'].startswith('0x'))
self.assertTrue(converted_result['txIndex'].startswith('0x'))
self.assertTrue(converted_result['to'].startswith('cx'))
self.assertTrue(converted_result['scoreAddress'].startswith('cx'))
self.assertTrue(converted_result['stepUsed'].startswith('0x'))
self.assertTrue(converted_result['logsBloom'].startswith('0x'))
self.assertTrue(converted_result['status'].startswith('0x'))
def test_revert(self, mocker):
mocker.patch.object(IconServiceEngine, "_charge_transaction_fee")
mocker.patch.object(IconScoreEngine, "invoke")
context = ContextContainer._get_context()
icon_service_engine = IconServiceEngine()
icon_service_engine._icx_engine = Mock(spec=IcxEngine)
icon_service_engine._icon_score_deploy_engine = \
Mock(spec=DeployEngine)
icon_service_engine._icon_pre_validator = Mock(spec=IconPreValidator)
context.tx_batch = TransactionBatch()
context.clear_batch = Mock()
context.update_batch = Mock()
from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20))
tx_index = randrange(0, 100)
context.tx = Transaction(os.urandom(32), tx_index, from_, 0)
context.msg = Message(from_)
def intercept_charge_transaction_fee(*args, **kwargs):
return {}, Mock(spec=int)
IconServiceEngine._charge_transaction_fee.side_effect = \
intercept_charge_transaction_fee
icon_service_engine._icon_score_deploy_engine.attach_mock(
Mock(return_value=False), 'is_data_type_supported')
reason = Mock(spec=str)
code = ExceptionCode.SCORE_ERROR
mock_revert = Mock(side_effect=IconScoreException(reason))
IconScoreEngine.invoke.side_effect = mock_revert
raise_exception_start_tag("test_revert")
tx_result = icon_service_engine._handle_icx_send_transaction(
context, {
'version': 3,
'from': from_,
'to': to_
})
raise_exception_end_tag("test_revert")
assert tx_result.status == 0
IconServiceEngine._charge_transaction_fee.assert_called()
context.traces.append.assert_called()
trace = context.traces.append.call_args[0][0]
assert trace.trace == TraceType.REVERT
assert trace.data[0] == code
assert trace.data[1] == reason
def make_origin_parameters(option: dict = None) -> dict:
params = make_required_parameters(
version=hex(3),
_from=str(Address.from_data(AddressPrefix.EOA, os.urandom(20))),
to=str(Address.from_data(random.choice([AddressPrefix.EOA, AddressPrefix.CONTRACT]), os.urandom(20))),
stepLimit=hex(random.randint(10, 5000)),
timestamp=hex(random.randint(10, 5000)),
signature='VAia7YZ2Ji6igKWzjR2YsGa2m53nKPrfK7uXYW78QLE+ATehAVZPC40szvAiA6NEU5gCYB4c4qaQzqDh2ugcHgA='
)
if option:
params.update(option)
return params
def setUp(self) -> None:
self.converter = PRepAddressConverter()
self.node_addresses = []
self.prep_addresses = []
# Generate sample addresses for test
for i in range(10):
node_address = Address.from_data(
AddressPrefix.EOA, f'node_address{i}'.encode("utf-8"))
prep_address = Address.from_data(
AddressPrefix.EOA, f'prep_address{i}'.encode("utf-8"))
self.node_addresses.append(node_address)
self.prep_addresses.append(prep_address)
def test_call_event_kwarg(self):
context = ContextContainer._get_context()
name = "name"
address = Address.from_data(AddressPrefix.EOA, b'address')
age = 10
# Call with ordered arguments
self._mock_score.OneIndexEvent(name, address, age)
self.assertEqual(len(context.event_logs), 1)
event_log_ordered_args = context.event_logs[0]
# Call with ordered arguments and keyword arguments
self._mock_score.OneIndexEvent(name, age=age, address=address)
self.assertEqual(len(context.event_logs), 2)
event_log_keyword_args = context.event_logs[1]
self.assertEqual(event_log_ordered_args.score_address,
event_log_keyword_args.score_address)
self.assertEqual(event_log_ordered_args.indexed,
event_log_keyword_args.indexed)
self.assertEqual(event_log_ordered_args.data,
event_log_keyword_args.data)
logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs)
one_event_bloom_data = \
int(0).to_bytes(1, DATA_BYTE_ORDER) + \
'OneIndexEvent(str,Address,int)'.encode('utf-8')
self.assertIn(one_event_bloom_data, logs_bloom)
name_bloom_data = int(1).to_bytes(
1, DATA_BYTE_ORDER) + name.encode('utf-8')
self.assertIn(name_bloom_data, logs_bloom)
def test_address_index_event(self):
context = ContextContainer._get_context()
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
# Tests simple event emit
self._mock_score.AddressIndexEvent(address)
self.assertEqual(1, len(context.event_logs))
event_log = context.event_logs[0]
self.assertEqual(2, len(event_log.indexed))
self.assertEqual(0, len(event_log.data))
logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs)
# Asserts whether the SCORE address is included in the bloom
self.assert_score_address_in_bloom(logs_bloom)
event_bloom_data = \
int(0).to_bytes(1, DATA_BYTE_ORDER) + \
'AddressIndexEvent(Address)'.encode('utf-8')
self.assertIn(event_bloom_data, logs_bloom)
indexed_bloom_data = int(1).to_bytes(1, DATA_BYTE_ORDER) + \
address.prefix.value.to_bytes(1, DATA_BYTE_ORDER) + address.body
self.assertEqual(ICON_ADDRESS_BYTES_SIZE + 1, len(indexed_bloom_data))
self.assertIn(indexed_bloom_data, logs_bloom)
def test_install_result(self):
self._icon_service_engine._icon_score_deploy_engine.attach_mock(
Mock(return_value=True), 'is_data_type_supported')
from_ = Address.from_data(AddressPrefix.EOA, b'test')
tx_index = Mock(spec=int)
self._mock_context.tx.attach_mock(tx_index, "index")
self._mock_context.tx.timestamp = 0
self._mock_context.tx.origin = from_
self._mock_context.tx.nonce = None
tx_result = self._icon_service_engine._handle_icx_send_transaction(
self._mock_context,
{
'version': 3,
'from': from_,
'to': ZERO_SCORE_ADDRESS,
'dataType': 'deploy',
'timestamp': 0,
'data': {
'contentType': 'application/tbears',
'content': '/home/haha'
}
}
)
self._icon_service_engine._charge_transaction_fee.assert_called()
self.assertEqual(1, tx_result.status)
self.assertEqual(tx_index, tx_result.tx_index)
self.assertEqual(ZERO_SCORE_ADDRESS, tx_result.to)
self.assertIsNotNone(tx_result.score_address)
camel_dict = tx_result.to_dict(to_camel_case)
self.assertNotIn('failure', camel_dict)
def setUp(self):
address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20))
db = Mock(spec=IconScoreDatabase)
db.attach_mock(address, 'address')
context = IconScoreContext()
traces = Mock(spec=list)
step_counter = Mock(spec=IconScoreStepCounter)
IconScoreContext.engine = ContextEngine(icx=Mock(IcxEngine),
deploy=Mock(DeployEngine),
fee=None,
iiss=None,
prep=None,
issue=None)
IconScoreContext.storage = ContextStorage(icx=Mock(IcxStorage),
deploy=Mock(DeployStorage),
fee=None,
iiss=None,
prep=None,
issue=None,
rc=None,
meta=None)
IconScoreContext.icx_engine = Mock(spec=IcxEngine)
context.type = IconScoreContextType.INVOKE
context.func_type = IconScoreFuncType.WRITABLE
context.tx_batch = TransactionBatch()
context.event_logs = []
context.traces = traces
context.step_counter = step_counter
context.get_owner = Mock()
ContextContainer._push_context(context)
self._mock_score = EventlogScore(db)
def test_reserved_event_log(self):
context = ContextContainer._get_context()
context.func_type = IconScoreFuncType.READONLY
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
with self.assertRaises(InvalidEventLogException):
self._mock_score.ICXTransfer(address, address, 0)
def test_throw(self, score_invoke, IconServiceEngine_charge_transaction_fee):
context = ContextContainer._get_context()
self._icon_service_engine = IconServiceEngine()
self._icon_service_engine._icx_engine = Mock(spec=IcxEngine)
self._icon_service_engine._icon_score_deploy_engine = \
Mock(spec=DeployEngine)
self._icon_service_engine._icon_pre_validator = Mock(
spec=IconPreValidator)
context.tx_batch = TransactionBatch()
context.clear_batch = Mock()
context.update_batch = Mock()
from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20))
tx_index = randrange(0, 100)
context.tx = Transaction(os.urandom(32), tx_index, from_, 0)
context.msg = Message(from_)
def intercept_charge_transaction_fee(*args, **kwargs):
return {}, Mock(spec=int)
IconServiceEngine_charge_transaction_fee.side_effect = \
intercept_charge_transaction_fee
self._icon_service_engine._icon_score_deploy_engine.attach_mock(
Mock(return_value=False), 'is_data_type_supported')
error = Mock(spec=str)
code = ExceptionCode.INVALID_PARAMETER
mock_exception = Mock(side_effect=InvalidParamsException(error))
score_invoke.side_effect = mock_exception
raise_exception_start_tag("test_throw")
tx_result = self._icon_service_engine._handle_icx_send_transaction(
context, {'version': 3, 'from': from_, 'to': to_})
raise_exception_end_tag("test_throw")
self.assertEqual(0, tx_result.status)
IconServiceEngine_charge_transaction_fee.assert_called()
context.traces.append.assert_called()
trace = context.traces.append.call_args[0][0]
self.assertEqual(TraceType.THROW, trace.trace)
self.assertEqual(code, trace.data[0])
self.assertEqual(error, trace.data[1])
def setUp(self):
self._inner_task = generate_inner_task(Revision.FOUR.value)
self.from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20))
self.to = Address.from_string('cx' + '0' * 40)
self.score = Address.from_string('cx' + '1' * 40)
IconScoreContext.engine.icx.transfer = Mock()
IconScoreContext.engine.icx.get_balance = Mock(return_value=5000)
IconScoreContext.engine.prep.preps = Mock()
def test_send_icx_without_data(self):
step_price = 10**10
default_step_cost = 100_000
input_step_cost = 200
value = 10**18
self._update_governance("0_0_6")
for revision in range(REVISION_2, LATEST_REVISION + 1):
self._set_revision_to_governance(revision, name="")
# Create a new to address every block
to = Address.from_data(AddressPrefix.EOA, f"to{revision}".encode())
genesis_balance0: int = self._query({"address": self._genesis},
'icx_getBalance')
self.assertTrue(genesis_balance0 > 0)
# Check "to" address balance. It should be 0
to_balance0: int = self._query({"address": to}, 'icx_getBalance')
self.assertEqual(0, to_balance0)
if revision == REVISION_3:
# Check backward compatibility on TestNet Database
# step_used increases by input_step_cost * len(json.dumps(None))
# because of None parameter handling error on get_input_data_size()
step_limit = default_step_cost + input_step_cost * len(
json.dumps(None))
self.assertEqual(default_step_cost + input_step_cost * 4,
step_limit)
else:
step_limit = default_step_cost
tx = self._make_icx_send_tx(self._genesis,
to,
value=value,
step_limit=step_limit)
prev_block, tx_results = self._make_and_req_block([tx])
self._write_precommit_state(prev_block)
tx_result: 'TransactionResult' = tx_results[0]
self.assertEqual(1, tx_result.status)
self.assertEqual(step_limit, tx_result.step_used)
self.assertEqual(to, tx_result.to)
self.assertIsNone(tx_result.failure)
self.assertIsNone(tx_result.score_address)
fee: int = tx_result.step_used * step_price
self.assertTrue(fee > 0)
to_balance: int = self._query({"address": to}, 'icx_getBalance')
self.assertEqual(value, to_balance)
genesis_balance1: int = self._query({"address": self._genesis},
'icx_getBalance')
self.assertEqual(genesis_balance0, genesis_balance1 + value + fee)
def test_put_and_get(self):
"""
"""
context = self.context
address = Address.from_data(AddressPrefix.CONTRACT, b'score')
value = 100
self.context_db._put(context, address.body, value.to_bytes(32, 'big'), True)
value = self.context_db.get(context, address.body)
self.assertEqual(100, int.from_bytes(value, 'big'))
def test_deposit_fee_invalid_param(self):
context = self.get_context()
tx_hash = os.urandom(32)
amount = randrange(FeeEngine._MIN_DEPOSIT_AMOUNT, FeeEngine._MAX_DEPOSIT_AMOUNT)
block_height = randrange(100, 10000)
term = get_rand_term()
# invalid amount (underflow)
# noinspection PyTypeChecker
with self.assertRaises(InvalidRequestException) as e:
inv_amount = randrange(0, FeeEngine._MIN_DEPOSIT_AMOUNT - 1)
self._engine.add_deposit(context, tx_hash, self._sender, self._score_address,
inv_amount, block_height, term)
# noinspection PyUnresolvedReferences
self.assertEqual('Invalid deposit amount', e.exception.message)
# invalid amount (overflow)
# noinspection PyTypeChecker
with self.assertRaises(InvalidRequestException) as e:
inv_amount = \
randrange(FeeEngine._MAX_DEPOSIT_AMOUNT + 1, FeeEngine._MAX_DEPOSIT_AMOUNT * 10)
self._engine.add_deposit(context, tx_hash, self._sender, self._score_address,
inv_amount, block_height, term)
# noinspection PyUnresolvedReferences
self.assertEqual('Invalid deposit amount', e.exception.message)
# invalid term (underflow)
# noinspection PyTypeChecker
with self.assertRaises(InvalidRequestException) as e:
inv_term = randrange(0, FeeEngine._MIN_DEPOSIT_TERM - 1)
self._engine.add_deposit(context, tx_hash, self._sender, self._score_address,
amount, block_height, inv_term)
# noinspection PyUnresolvedReferences
self.assertEqual('Invalid deposit term', e.exception.message)
# invalid term (overflow)
# noinspection PyTypeChecker
with self.assertRaises(InvalidRequestException) as e:
inv_term = \
randrange(FeeEngine._MAX_DEPOSIT_TERM + 1, FeeEngine._MAX_DEPOSIT_TERM * 10)
self._engine.add_deposit(context, tx_hash, self._sender, self._score_address,
amount, block_height, inv_term)
# noinspection PyUnresolvedReferences
self.assertEqual('Invalid deposit term', e.exception.message)
# invalid owner
# noinspection PyTypeChecker
with self.assertRaises(InvalidRequestException) as e:
inv_sender = Address.from_data(AddressPrefix.EOA, os.urandom(20))
self._engine.add_deposit(context, tx_hash, inv_sender, self._score_address,
amount, block_height, term)
# noinspection PyUnresolvedReferences
self.assertEqual('Invalid SCORE owner', e.exception.message)
def test_handle_system_call_with_kwargs(self):
from_ = GOVERNANCE_ADDRESS
score_address = Address.from_data(AddressPrefix.CONTRACT,
os.urandom(20))
args = {'address': score_address}
system_call_handler.handle_system_call(self.context, from_, 0,
'getScoreDepositInfo', None,
args)
self.context.engine.fee.get_deposit_info.assert_called_with(
self.context, score_address, self.block_height)
def test_icx_transfer_event(self):
context = ContextContainer._get_context()
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
# Tests simple event emit
self._mock_score.icx.send(address, 1)
self.assertEqual(len(context.event_logs), 1)
event_log = context.event_logs[0]
self.assertEqual(4, len(event_log.indexed))
self.assertEqual(ICX_TRANSFER_EVENT_LOG, event_log.indexed[0])
self.assertEqual(0, len(event_log.data))
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'0')
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
self.db = IconScoreDatabase(address, context_db=context_db, prefix=b'')
self.address = address
def test_handle_system_call_with_invalid_kwargs(self):
from_ = GOVERNANCE_ADDRESS
score_address = Address.from_data(AddressPrefix.CONTRACT,
os.urandom(20))
args = {'address1': score_address}
# noinspection PyTypeChecker
with self.assertRaises(InvalidParamsException) as e:
assert e is not None
system_call_handler.handle_system_call(self.context, from_, 0,
'getScoreDepositInfo', None,
args)
self.context.engine.fee.get_deposit_info.assert_not_called()
def setUp(self):
context = IconScoreContext(IconScoreContextType.DIRECT)
block = Mock(spec=Block)
block.attach_mock(Mock(return_value=0), 'height')
context.block = block
self._sender = Address.from_data(AddressPrefix.EOA, os.urandom(20))
self._score_address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20))
context_db = create_context_db()
self.deploy_storage = DeployStorage(context_db)
deploy_info = IconScoreDeployInfo(self._score_address,
DeployState.ACTIVE,
self._sender,
os.urandom(32),
os.urandom(32))
self.icx_storage = IcxStorage(context_db)
self._icx_engine = IcxEngine()
self.fee_storage = FeeStorage(context_db)
patch_fee_storage(self.fee_storage)
self.deploy_storage.put_deploy_info(context, deploy_info)
context.storage = ContextStorage(deploy=self.deploy_storage, fee=self.fee_storage, icx=self.icx_storage,
iiss=None, prep=None, issue=None, rc=None, meta=None)
context.engine = ContextEngine(deploy=None, fee=None, icx=self._icx_engine, iiss=None, prep=None, issue=None)
self._icx_engine.open(self.icx_storage)
self.icx_storage._put_genesis_data_account(context,
CoinPartType.GENERAL,
self._sender,
100000000 * 10 ** 18)
self.icx_storage._put_genesis_data_account(context, CoinPartType.TREASURY,
Address.from_data(AddressPrefix.EOA, os.urandom(20)), 0)
self._engine = FeeEngine()
def test_freeze(create_prep_container):
size: int = 100
preps: 'PRepContainer' = create_prep_container(size)
preps.freeze()
i = random.randint(0, size - 1)
prep = preps.get_by_index(i)
with pytest.raises(AccessDeniedException):
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
preps.add(PRep(address))
with pytest.raises(AccessDeniedException):
preps.remove(prep.address)
def setUp(self):
self.mem_db = {}
self.key_ = b"key1"
self.last_value = None
def get(caller, key):
return self.last_value
score_address = Address.from_data(AddressPrefix.CONTRACT, b'score')
context_db = Mock(spec=ContextDatabase)
context_db.get = get
self._observer = Mock(spec=DatabaseObserver)
self._icon_score_database = IconScoreDatabase(score_address,
context_db)
self._icon_score_database.set_observer(self._observer)
def test_to_dict_camel(self):
context = ContextContainer._get_context()
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
age = 10
data = b'0123456789abc'
self._mock_score.MixedEvent(b'i_data', address, age, data, 'text')
self.assertEqual(len(context.event_logs), 1)
event_log = context.event_logs[0]
camel_dict = event_log.to_dict(to_camel_case)
self.assertIn('scoreAddress', camel_dict)
self.assertIn('indexed', camel_dict)
self.assertIn('data', camel_dict)
self.assertEqual(3, len(camel_dict['indexed']))
self.assertEqual(3, len(camel_dict['data']))
def setUp(self):
address = Address.from_data(AddressPrefix.CONTRACT, b'address')
db = Mock(spec=IconScoreDatabase)
db.attach_mock(address, 'address')
context = IconScoreContext()
traces = Mock(spec=list)
step_counter = Mock(spec=IconScoreStepCounter)
context.type = IconScoreContextType.INVOKE
context.func_type = IconScoreFuncType.WRITABLE
context.tx_batch = TransactionBatch()
context.event_logs = []
context.traces = traces
context.step_counter = step_counter
context.get_owner = Mock()
context.internal_call.icx_engine = Mock(spec=IcxEngine)
ContextContainer._push_context(context)
self._mock_score = EventlogScore(db)
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'score')
context = IconScoreContext(IconScoreContextType.INVOKE)
context.block_batch = BlockBatch()
context.tx_batch = TransactionBatch()
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
meta_context_db = MetaContextDatabase(context_db.key_value_db)
self.context_db = context_db
self.meta_context_db = meta_context_db
self.address = address
self.context = context
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'score')
context_factory = IconScoreContextFactory(max_size=2)
context = context_factory.create(IconScoreContextType.INVOKE)
context.block_batch = BlockBatch()
context.tx_batch = TransactionBatch()
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
self.context_factory = context_factory
self.context_db = context_db
self.address = address
self.context = context
def test_call_event(self):
context = ContextContainer._get_context()
name = "name"
address = Address.from_data(AddressPrefix.EOA, os.urandom(20))
age = 10
phone_number = "000"
# Tests simple event emit
self._mock_score.ZeroIndexEvent(name, address, age)
self.assertEqual(len(context.event_logs), 1)
event_log = context.event_logs[0]
self.assertEqual(1, len(event_log.indexed))
self.assertEqual(3, len(event_log.data))
# This event has a indexed parameter,
# so the list of indexed Should have 2 items
self._mock_score.OneIndexEvent(name, address, age)
self.assertEqual(len(context.event_logs), 2)
event_log = context.event_logs[1]
self.assertEqual(2, len(event_log.indexed))
self.assertEqual(2, len(event_log.data))
logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs)
# Asserts whether the SCORE address is included in the bloom
self.assert_score_address_in_bloom(logs_bloom)
zero_event_bloom_data = \
int(0).to_bytes(1, DATA_BYTE_ORDER) + \
'ZeroIndexEvent(str,Address,int)'.encode('utf-8')
self.assertIn(zero_event_bloom_data, logs_bloom)
one_event_bloom_data = \
int(0).to_bytes(1, DATA_BYTE_ORDER) + \
'OneIndexEvent(str,Address,int)'.encode('utf-8')
self.assertIn(one_event_bloom_data, logs_bloom)
name_bloom_data = int(1).to_bytes(
1, DATA_BYTE_ORDER) + name.encode('utf-8')
self.assertIn(name_bloom_data, logs_bloom)
