def test_int_to_bytes(self): n = 0x80 for i in range(0, 32): # 0x80, 0x8000, 0x800000, 0x80000000, ... data = int_to_bytes(-n) self.assertEqual(0x80, data[0]) # 0x0080, 0x008000, 0x00800000, 0x0080000000, ... data = int_to_bytes(n) first, second = data[:2] self.assertListEqual([0x00, 0x80], [first, second]) n <<= 8
def test_int_index_event(self): context = ContextContainer._get_context() amount = 123456789 # Tests simple event emit self._mock_score.IntIndexEvent(amount) self.assertEqual(len(context.event_logs), 1) 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) + \ 'IntIndexEvent(int)'.encode('utf-8') self.assertIn(event_bloom_data, logs_bloom) indexed_bloom_data = \ int(1).to_bytes(1, DATA_BYTE_ORDER) + int_to_bytes(amount) self.assertIn(indexed_bloom_data, logs_bloom)
def test_array_db(self, context, key_value_db, values, value_type): context_db = ContextDatabase(key_value_db, is_shared=False) address = Address(AddressPrefix.CONTRACT, os.urandom(20)) score_db = IconScoreDatabase(address, context_db) self._init_context(context, score_db.address) self._set_revision(context, Revision.USE_RLP.value - 1) name = "array_db" array_db = ArrayDB(name, score_db, value_type) for i in range(2): array_db.put(values[i]) assert len(array_db) == 2 self._set_revision(context, Revision.USE_RLP.value) array_db.put(values[2]) array_db.put(values[3]) assert len(array_db) == 4 for i, value in enumerate(array_db): assert value == values[i] final_key: bytes = _get_final_key(address, ContainerTag.ARRAY, name.encode(), use_rlp=True) assert key_value_db.get(final_key) == int_to_bytes(len(array_db)) for i, use_rlp in enumerate((False, False, True, True)): key = _get_final_key( address.to_bytes(), ContainerTag.ARRAY.value, name.encode(), int_to_bytes(i), use_rlp=use_rlp, ) assert key_value_db.get(key) == ContainerUtil.encode_value(values[i]) for v in reversed(values): assert v == array_db.pop() assert len(array_db) == 0 # 2 values for array_db size still remain # even though all items in array_db have been popped. assert len(key_value_db) == 2
def test_get_final_key_4(self, size): keys = [Key(f"prefix{i}".encode()) for i in range(size)] prefixes = PrefixStorage(keys) assert prefixes._tag is None assert len(prefixes) == size for key, expected in zip(prefixes, keys): assert key is expected name = Key(b"array", KeyType.ARRAY) prefixes.append(name) assert prefixes._tag is ContainerTag.ARRAY assert len(prefixes) == size + 1 last_key = int_to_bytes(0) final_key: bytes = prefixes.get_final_key(last_key, use_rlp=False) assert final_key == _get_final_key(*keys[:size], ContainerTag.ARRAY, name, last_key, use_rlp=False) final_key: bytes = prefixes.get_final_key(last_key, True) assert final_key == _get_final_key(ContainerTag.ARRAY, *prefixes, last_key, use_rlp=True)
def run(self, args): db_path: str = args.db score_address: "Address" = Address.from_string(args.score) address: "Address" = Address.from_string(args.user) balance: int = args.balance # Name of DictDB in Standard Token name: str = "balances" manager = ScoreDatabaseManager() manager.open(db_path, score_address) if balance < 0: value: bytes = manager.read_from_dict_db(name, address) balance: int = int.from_bytes(value, "big") print(f"token balance: {balance}") else: value: bytes = int_to_bytes(balance) manager.write_to_dict_db(name, address, value) manager.close()
def run_command_token(args): db_path: str = args.db score_address: 'Address' = Address.from_string(args.score) address: 'Address' = Address.from_string(args.user) balance: int = args.balance # Name of DictDB in Standard Token name: str = 'balances' manager = ScoreDatabaseManager() manager.open(db_path, score_address) if balance < 0: value: bytes = manager.read_from_dict_db(name, address) balance: int = int.from_bytes(value, 'big') print(f'token balance: {balance}') else: value: bytes = int_to_bytes(balance) manager.write_to_dict_db(name, address, value) manager.close()
def test_bool_index_event(self): context = ContextContainer._get_context() yes_no = True # Tests simple event emit self._mock_score.BoolIndexEvent(yes_no) self.assertEqual(len(context.event_logs), 1) 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) event_bloom_data = \ int(0).to_bytes(1, DATA_BYTE_ORDER) + \ 'BoolIndexEvent(bool)'.encode('utf-8') self.assertIn(event_bloom_data, logs_bloom) indexed_bloom_data = \ int(1).to_bytes(1, DATA_BYTE_ORDER) + int_to_bytes(yes_no) self.assertIn(indexed_bloom_data, logs_bloom)
def test_iterator(self): version: int = 7 msg_id: int = 1234 block_height: int = 100 state_hash: bytes = hashlib.sha3_256(b'').digest() block_hash: bytes = hashlib.sha3_256(b'block_hash').digest() tx_index: int = 1 tx_hash: bytes = hashlib.sha3_256(b"tx_hash").digest() address = Address.from_data(AddressPrefix.EOA, b'') iscore: int = 5000 success: bool = True status: int = 1 messages = [ (MessageType.VERSION, msg_id, (version, block_height)), (MessageType.CALCULATE, msg_id, (status, block_height)), (MessageType.QUERY, msg_id, (address.to_bytes_including_prefix(), int_to_bytes(iscore), block_height)), (MessageType.CLAIM, msg_id, (address.to_bytes_including_prefix(), block_height, block_hash, tx_index, tx_hash, int_to_bytes(iscore))), (MessageType.COMMIT_BLOCK, msg_id, (success, block_height, block_hash)), (MessageType.COMMIT_CLAIM, msg_id), (MessageType.READY, msg_id, (version, block_height, block_hash)), (MessageType.CALCULATE_DONE, msg_id, (success, block_height, int_to_bytes(iscore), state_hash)), (MessageType.INIT, msg_id, (success, block_height)) ] for message in messages: data: bytes = msgpack.packb(message) self.unpacker.feed(data) it = iter(self.unpacker) version_response = next(it) self.assertIsInstance(version_response, VersionResponse) self.assertEqual(version, version_response.version) calculate_response = next(it) self.assertIsInstance(calculate_response, CalculateResponse) query_response = next(it) self.assertIsInstance(query_response, QueryResponse) self.assertEqual(iscore, query_response.iscore) self.assertEqual(block_height, query_response.block_height) claim_response = next(it) self.assertIsInstance(claim_response, ClaimResponse) self.assertEqual(iscore, claim_response.iscore) self.assertEqual(block_height, claim_response.block_height) self.assertEqual(tx_index, claim_response.tx_index) self.assertEqual(tx_hash, claim_response.tx_hash) commit_block_response = next(it) self.assertIsInstance(commit_block_response, CommitBlockResponse) self.assertEqual(block_height, commit_block_response.block_height) self.assertEqual(block_hash, commit_block_response.block_hash) commit_claim_response = next(it) self.assertIsInstance(commit_claim_response, CommitClaimResponse) ready_notification = next(it) self.assertIsInstance(ready_notification, ReadyNotification) self.assertEqual(version, ready_notification.version) self.assertEqual(block_height, ready_notification.block_height) self.assertEqual(block_hash, ready_notification.block_hash) calculate_done_notification = next(it) self.assertIsInstance(calculate_done_notification, CalculateDoneNotification) self.assertTrue(calculate_done_notification.success) self.assertEqual(block_height, calculate_done_notification.block_height) self.assertEqual(state_hash, calculate_done_notification.state_hash) init_response = next(it) self.assertIsInstance(init_response, InitResponse) self.assertEqual(success, init_response.success) self.assertEqual(block_height, init_response.block_height) with self.assertRaises(StopIteration): next(it) for message in messages: data: bytes = msgpack.packb(message) self.unpacker.feed(data) expected = [ version_response, calculate_response, query_response, claim_response, commit_block_response, commit_claim_response, ready_notification, calculate_done_notification ] for expected_response, response in zip(expected, self.unpacker): self.assertEqual(expected_response.MSG_TYPE, response.MSG_TYPE) self.assertEqual(msg_id, response.msg_id)