def test_address_from_to_string_EOA2(self): addr1 = create_address() buf = bytes.hex(addr1.body) with self.assertRaises(BaseException) as e: Address.from_string(buf) self.assertEqual(e.exception.code, ExceptionCode.INVALID_PARAMS) self.assertEqual(e.exception.message, 'Invalid address')
def from_dict(cls, data: Dict[str, Union[str, List]]) -> "TransactionResult": status = cls.Status(str_to_int(data["status"])) to: "Address" = Address.from_string(data["to"]) score_address: "Address" = Address.from_string( data["scoreAddress"]) if "scoreAddress" in data else None tx_hash: bytes = hex_to_bytes(data["txHash"]) tx_index: int = str_to_int(data["txIndex"]) block_height: int = str_to_int(data["blockHeight"]) block_hash: bytes = hex_to_bytes(data["blockHash"]) step_price: int = str_to_int(data["stepPrice"]) step_used: int = str_to_int(data["stepUsed"]) event_logs: List["EventLog"] = cls._parse_event_logs(data["eventLogs"]) return TransactionResult( status=status, to=to, score_address=score_address, tx_hash=tx_hash, tx_index=tx_index, block_height=block_height, block_hash=block_hash, step_price=step_price, step_used=step_used, event_logs=event_logs, )
def _genesis_invoke(self) -> dict: tx_hash = create_tx_hash() timestamp_us = create_timestamp() request_params = { 'txHash': tx_hash, 'version': 3, 'timestamp': timestamp_us } tx = { 'method': 'icx_sendTransaction', 'params': request_params, 'genesisData': { "accounts": [ { "name": "genesis", "address": Address.from_string(self._genesis.get_address()), "balance": 100 * self._icx_factor }, { "name": "fee_treasury", "address": Address.from_string(self._fee_treasury.get_address()), "balance": 0 }, { "name": "_admin", "address": Address.from_string(self._test1.get_address()), "balance": 1_000_000 * self._icx_factor } ] }, }
def setUp(self): empty_address = MalformedAddress.from_string('') short_address_without_hx = MalformedAddress.from_string('12341234') short_address = MalformedAddress.from_string('hx1234512345') long_address_without_hx = MalformedAddress.from_string( 'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf') long_address = MalformedAddress.from_string( 'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf' ) self.malformed_addresses = [ empty_address, short_address_without_hx, short_address, long_address_without_hx, long_address ] self.db_name = 'engine.db' db = ContextDatabase.from_path(self.db_name) self.engine = IcxEngine() self._from = Address.from_string('hx' + 'a' * 40) self.to = Address.from_string('hx' + 'b' * 40) self.genesis_address = Address.from_string('hx' + '0' * 40) self.fee_treasury_address = Address.from_string('hx' + '1' * 40) self.total_supply = 10**20 # 100 icx self.context = IconScoreContext(IconScoreContextType.DIRECT) icx_storage = IcxStorage(db) self.engine.open(icx_storage) self.engine.init_account(self.context, AccountType.GENESIS, 'genesis', self.genesis_address, self.total_supply) self.engine.init_account(self.context, AccountType.TREASURY, 'treasury', self.fee_treasury_address, 0)
def test_init_account(self): def intercept_storage_put_account(context: 'IconScoreContext', address: 'Address', account: 'Account'): if not (isinstance(address, Address) and isinstance(account, Account)): raise Exception( "invalid type of params was set when calling put_account") self.engine._init_special_account = Mock() self.engine._storage.put_account = Mock( side_effect=intercept_storage_put_account) genesis_address = Address.from_string('hx' + 'f' * 40) self.engine.init_account(self.context, AccountType.GENESIS, 'genesis', genesis_address, 1000) self.total_supply += 1000 self.engine._storage.put_account.assert_called() self.engine._init_special_account.assert_called() self.assertEqual(self.total_supply, self.engine._total_supply_amount) self.engine._init_special_account = Mock() general_addr = Address.from_string('hx' + 'f' * 40) self.engine.init_account(self.context, AccountType.GENERAL, 'general', general_addr, 1000) self.total_supply += 1000 self.engine._storage.put_account.assert_called() self.engine._init_special_account.assert_not_called() self.assertEqual(self.total_supply, self.engine._total_supply_amount)
def process_call(self, call: Call, network: IconService = None): if self._network_only and network is None: raise URLException("Set network URL") try: if network is not None: response = network.call(call) else: request = { "from": Address.from_string(call.from_), "to": Address.from_string(call.to), "dataType": "call", "data": { "method": call.method } } if isinstance(call.params, dict): request["data"]["params"] = call.params response = self._query(request=request) except IconServiceBaseException as e: response = e.message return response
def test_registerAddress(self): eoa_address = Address.from_string("hx" + "3" * 40) network_id = self.registry_score.NETWORK network_address = Address.from_string("cx" + "2" * 40) with patch_property(IconScoreBase, 'msg', Message(self.registry_owner)): # failure case: invalid register score address self.assertRaises(RevertException, self.registry_score.registerAddress, network_id, ZERO_SCORE_ADDRESS) # failure case: try to register eoa address self.assertRaises(RevertException, self.registry_score.registerAddress, network_id, eoa_address) # failure case: score name is not in the SCORE_KEYS non_listed_id = "NON_LISTED_SCORE_ID" self.assertRaises(RevertException, self.registry_score.registerAddress, non_listed_id, network_address) # success case: register network self.registry_score.registerAddress(network_id, network_address) self.assertEqual(network_address, self.registry_score._score_address[network_id]) self.registry_score.AddressUpdate.assert_called_with( network_id, network_address)
def from_dict(cls, data: Dict[str, str]) -> "Transaction": version = str_to_int(data.get("version", "0x2")) nid = str_to_int(data.get("nid", "0x1")) from_ = Address.from_string(data["from"]) to = Address.from_string(data["to"]) value = str_to_int(data.get("value", "0x0")) tx_hash = cls._get_tx_hash(data) timestamp = str_to_int(data["timestamp"]) signature: bytes = base64.b64decode(data["signature"]) data_type = data.get("dataType") step_limit = str_to_int( data["stepLimit"]) if "stepLimit" in data else 0 if "nonce" in data: nonce = str_to_int(data["nonce"]) else: nonce = None tx_data = cls._get_data(data_type, data.get("data")) return Transaction( version=version, nid=nid, from_=from_, to=to, value=value, tx_hash=tx_hash, signature=signature, step_limit=step_limit, timestamp=timestamp, data_type=data_type, data=tx_data, nonce=nonce, )
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_icx_token_deposit(self): initial_owner_icx_value = self._get_icx_value( Address.from_string(self._test1.get_address())) deposit_icx = 10 * 10**18 # Success case: deposit 10 icx to icx_token tx_result = self._transaction_call_default(self.icx_token_address, "deposit", {}, deposit_icx) # Checks event log (Issuance) self.assertEqual(deposit_icx, int(tx_result["eventLogs"][0]["data"][0], 0)) # Checks event log (Transfer) self.assertEqual(self.icx_token_address, tx_result["eventLogs"][1]["indexed"][1]) self.assertEqual(self._test1.get_address(), tx_result["eventLogs"][1]["indexed"][2]) self.assertEqual(deposit_icx, int(tx_result["eventLogs"][1]["indexed"][3], 0)) # Checks owner token balance (should be 10 * 10 ** 18) actual_icx_balance = self._icx_call_default( self.icx_token_address, "balanceOf", {"_owner": self._test1.get_address()}) self.assertEqual(deposit_icx, int(actual_icx_balance, 0)) # Checks icx token's total supply (should be 10 * 10 ** 18) actual_total_supply = self._icx_call_default(self.icx_token_address, "totalSupply") self.assertEqual(deposit_icx, int(actual_total_supply, 0)) owner_icx_value = self._get_icx_value( Address.from_string(self._test1.get_address())) icx_token_score_value = self._get_icx_value( Address.from_string(self.icx_token_address)) # Checks real ICX coin balance self.assertEqual( int(initial_owner_icx_value, 0) - deposit_icx, int(owner_icx_value, 0)) self.assertEqual(deposit_icx, int(icx_token_score_value, 0)) # Success case: deposit 10 icx without calling deposit method by sending icx to score address icx_transfer_call(super(), self._test1, self.icx_token_address, deposit_icx, self.icon_service) # Checks owner token balance (should be 10 * 10 ** 18 * 2) actual_icx_balance = self._icx_call_default( self.icx_token_address, "balanceOf", {"_owner": self._test1.get_address()}) self.assertEqual(deposit_icx * 2, int(actual_icx_balance, 0)) # Checks icx token's total supply (should be 10 * 10 ** 18 * 2) actual_total_supply = self._icx_call_default(self.icx_token_address, "totalSupply") self.assertEqual(deposit_icx * 2, int(actual_total_supply, 0))
def convert_to_address(to: str) -> Union['Address', 'MalformedAddress']: try: address = Address.from_string(to) except InvalidParamsException: address = MalformedAddress.from_string(to) return address
def convert_transaction_to_request(loopchain_block: "LoopchainBlock", tx_dict: dict): params = {} request = {"method": "icx_sendTransaction", "params": params} if "from" in tx_dict: params["from"] = Address.from_string(tx_dict["from"]) if "to" in tx_dict: params["to"] = convert_to_address(tx_dict["to"]) if "tx_hash" in tx_dict: params["txHash"] = bytes.fromhex(tx_dict["tx_hash"]) else: params["txHash"] = bytes.fromhex(tx_dict["txHash"]) if "timestamp" in tx_dict: params["timestamp"] = str_to_int(tx_dict["timestamp"]) else: params["timestamp"] = loopchain_block.timestamp int_keys = ["version", "fee", "nid", "value", "nonce", "stepLimit"] for key in int_keys: if key in tx_dict: params[key] = int(tx_dict[key], 16) object_keys = ["dataType", "data", "signature"] for key in object_keys: if key in tx_dict: params[key] = tx_dict[key] data_type: str = tx_dict.get("dataType", "") if data_type == "base": params["data"] = convert_base_transaction(tx_dict["data"]) return request
def _from_dict_recent_v(cls, block: dict) -> "LoopchainBlock": # In case of version >= 0.3 version: str = block["version"] height: int = str_to_int(block["height"]) block_hash: bytes = convert_hex_str_to_bytes(block["hash"]) prev_block_hash: bytes = convert_hex_str_to_bytes(block["prevHash"]) leader = Address.from_string(block["leader"]) timestamp: int = str_to_int(block["timestamp"]) state_hash: bytes = convert_hex_str_to_bytes(block["stateHash"]) prev_votes: Optional[list] = block.get("prevVotes") transactions: list = block["transactions"] reps_hash: Optional[bytes] = None if "repsHash" in block: reps_hash: Optional[bytes] = convert_hex_str_to_bytes( block["repsHash"]) return LoopchainBlock( version=version, height=height, block_hash=block_hash, timestamp=timestamp, prev_block_hash=prev_block_hash, state_hash=state_hash, leader=leader, prev_votes=prev_votes, transactions=transactions, reps_hash=reps_hash, )
def convert_transaction_to_request(loopchain_block: 'LoopchainBlock', tx_dict: dict): params = {} request = {'method': 'icx_sendTransaction', 'params': params} params['from'] = Address.from_string(tx_dict['from']) params['to'] = convert_to_address(tx_dict['to']) if 'tx_hash' in tx_dict: params['txHash'] = bytes.fromhex(tx_dict['tx_hash']) else: params['txHash'] = bytes.fromhex(tx_dict['txHash']) if 'timestamp' in tx_dict: params['timestamp'] = str_to_int(tx_dict['timestamp']) else: params['timestamp'] = loopchain_block.timestamp int_keys = ['version', 'fee', 'nid', 'value', 'nonce', 'stepLimit'] for key in int_keys: if key in tx_dict: params[key] = int(tx_dict[key], 16) object_keys = ['dataType', 'data', 'signature'] for key in object_keys: if key in tx_dict: params[key] = tx_dict[key] return request
def tx_dict_to_params(tx_dict: dict, block_timestamp: int) -> dict: params = {} if "from" in tx_dict: params["from"] = Address.from_string(tx_dict["from"]) if "to" in tx_dict: params["to"] = convert_to_address(tx_dict["to"]) if "tx_hash" in tx_dict: params["txHash"] = bytes.fromhex(tx_dict["tx_hash"]) else: params["txHash"] = bytes.fromhex(tx_dict["txHash"]) if "timestamp" in tx_dict: params["timestamp"] = str_to_int(tx_dict["timestamp"]) else: params["timestamp"] = block_timestamp int_keys = ["version", "fee", "nid", "value", "nonce", "stepLimit"] for key in int_keys: if key in tx_dict: params[key] = int(tx_dict[key], 16) object_keys = ["dataType", "data", "signature"] for key in object_keys: if key in tx_dict: params[key] = tx_dict[key] data_type: str = tx_dict.get("dataType", "") if data_type == "base": params["data"] = convert_base_transaction(tx_dict["data"]) return params
def from_dict(block: dict) -> 'LoopchainBlock': version: str = block['version'] prev_block_hash: bytes = bytes.fromhex(block['prev_block_hash']) merkle_tree_root_hash: bytes = bytes.fromhex( block['merkle_tree_root_hash']) timestamp: int = block['time_stamp'] block_hash: bytes = bytes.fromhex(block['block_hash']) height: int = block['height'] peer_id = block['peer_id'] if peer_id: peer_id: 'Address' = Address.from_string(peer_id) else: peer_id = None try: commit_state: bytes = bytes.fromhex( block['commit_state']['icon_dex']) except: commit_state: bytes = b'' loopchain_block = LoopchainBlock( version=version, prev_block_hash=prev_block_hash, merkle_tree_hash=merkle_tree_root_hash, timestamp=timestamp, block_hash=block_hash, height=height, peer_id=peer_id, commit_state=commit_state) loopchain_block.transactions: dict = block[ 'confirmed_transaction_list'] return loopchain_block
def run(self, args): """Print the account info of a given address :param args: :return: """ db_path: str = args.db address: "Address" = Address.from_string(args.address) reader = StateDatabaseReader() try: reader.open(db_path) block = reader.get_last_block() print(f"BH: {block.height}") account: "Account" = reader.get_account( address, reader.get_last_block().height, 10) if account is None: print(f"Account not found: {address}") else: print(f"address: {account.address}\n" f"amount (loop): {account.balance:_}\n" f"stake: {account.stake_part.stake:_}\n" f"unstake: {account.stake_part.unstake:_}\n" f"unstakeInfo: {account.stake_part.unstakes_info}\n" f"total: {account.balance + account.total_stake:_}\n") finally: reader.close()
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 get_balance(self, address: str) -> int: if self.icon_service is not None: return self.icon_service.get_balance(address) params = {'address': Address.from_string(address)} response = self.icon_service_engine.query(method="icx_getBalance", params=params) return response
def from_dict(cls, data: Optional[dict]) -> "Vote": """ { "blockHash’: ‘0xd5cc6d2d6998dd6d6f9c544232956bcf1108003b5253e8383d7628a10939913a’, "blockHeight’: ‘0x9e1ce3’, ‘rep’: ‘hxd0d9b0fee857de26fd1e8b15209ca15b14b851b2’, ‘round_‘: 1, ‘signature’: ‘SDsaAJ6FZdgdFeS0eBVxj/CGCcvIghkqBiUmKRFcup9VSBVo5K+oJHgvNjL7CSBCj1+AHrERDKHYdROyIhxbmAE=’, ‘timestamp’: ‘0x5960a8b1afc92’ } :param data: :return: """ rep: Address = Address.from_string(data["rep"]) height: int = str_to_int(data["blockHeight"]) block_hash: bytes = convert_hex_str_to_bytes(data["blockHash"]) timestamp: int = str_to_int(data["timestamp"]) # Block 0.4: round_ # Block 0.5: round round_: int = data.get("round", data.get("round_")) return Vote( rep=rep, block_height=height, block_hash=block_hash, timestamp=timestamp, round=round_, )
def setUp(self): empty_address = MalformedAddress.from_string('') short_address_without_hx = MalformedAddress.from_string('12341234') short_address = MalformedAddress.from_string('hx1234512345') long_address_without_hx = MalformedAddress.from_string( 'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf') long_address = MalformedAddress.from_string( 'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf' ) self.malformed_addresses = [ empty_address, short_address_without_hx, short_address, long_address_without_hx, long_address ] self.db_name = 'engine.db' db = ContextDatabase.from_path(self.db_name) self.engine = IcxEngine() self._from = Address.from_string('hx' + 'a' * 40) self.to = Address.from_string('hx' + 'b' * 40) self.genesis_address = Address.from_string('hx' + '0' * 40) self.fee_treasury_address = Address.from_string('hx' + '1' * 40) self.total_supply = 10**20 # 100 icx self.context = IconScoreContext(IconScoreContextType.DIRECT) block = Mock(spec=Block) block.attach_mock(Mock(return_value=0), 'height') self.context.block = block self.storage = IcxStorage(db) self.engine.open() accounts: list = [{ 'address': self.genesis_address, 'balance': self.total_supply }, { 'address': self.fee_treasury_address, 'balance': 0 }] self.context.storage = ContextStorage(deploy=None, fee=None, icx=self.storage, iiss=None, prep=None, issue=None, rc=None, meta=None) self.storage.put_genesis_accounts(self.context, accounts)
def __init__(self, db_path: str): self._db: TbearsDB = TbearsDB(TbearsDB.make_db(db_path)) self._block_height = -1 self._prev_block_hash = None self._peer_id: str = str( Address.from_string("hx6e1dd0d4432620778b54b2bbc21ac3df961adf89")) self.load_block_info()
def setUp(self): self.patcher = ScorePatcher(ScoreRegistry) self.patcher.start() self.score_address = Address.from_string("cx" + "1" * 40) self.registry_score = ScoreRegistry(create_db(self.score_address)) self.registry_owner = Address.from_string("hx" + "1" * 40) with patch_property(IconScoreBase, 'msg', Message(self.registry_owner)): self.registry_score.on_install() Owned.on_install.assert_called_with(self.registry_score) # success case: when deploy ScoreRegistry, score registry address should be registered by default self.assertEqual \ (self.score_address, self.registry_score._score_address[self.registry_score.SCORE_REGISTRY.encode()])
def setUp(self): self._state_db_root_path = '.db' self._score_root_path = '.score' rmtree(self._score_root_path) rmtree(self._state_db_root_path) engine = IconServiceEngine() conf = IconConfig("", default_icon_config) conf.load() conf.update_conf({ ConfigKey.BUILTIN_SCORE_OWNER: str(create_address(AddressPrefix.EOA)), ConfigKey.SCORE_ROOT_PATH: self._score_root_path, ConfigKey.STATE_DB_ROOT_PATH: self._state_db_root_path }) # engine._load_builtin_scores = Mock() # engine._init_global_value_by_governance_score = Mock() engine.open(conf) self._engine = engine self._genesis_address = create_address(AddressPrefix.EOA) self._treasury_address = create_address(AddressPrefix.EOA) self._governance_score_address =\ Address.from_string('cx0000000000000000000000000000000000000001') self.from_ = self._genesis_address self._to = create_address(AddressPrefix.EOA) self._icon_score_address = create_address(AddressPrefix.CONTRACT) self._total_supply = 100 * 10**18 accounts = [{ 'name': 'god', 'address': self._genesis_address, 'balance': self._total_supply }, { 'name': 'treasury', 'address': self._treasury_address, 'balance': 0 }] block = Block(0, create_block_hash(), 0, None) tx = { 'method': '', 'params': { 'txHash': create_tx_hash() }, 'genesisData': { 'accounts': accounts } } tx_lists = [tx] self._engine.invoke(block, tx_lists) self._engine.commit(block) self.genesis_block = block
def test_convert_by_path(self): # success case: check all other SCORE's methods called correctly # in this path, 'flexible token' is 1, 3, 'from token' is 0, 2, 'to token' is 2, 4 ( index ) converted_path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.connector_token_list[1], self.flexible_token_address_list[1], self.connector_token_list[2] ] for_address = Address.from_string("hx" + "a" * 40) # this method substitutes 'create_interface_score' method of IconScoreBase def create_interface_score_mock(token_address, interface_score): if interface_score.__name__ == 'ProxyScore(ABCFlexibleToken)': # add getOwner method to the token address instance # this token instance operates as a converter interface score token_address.getOwner = Mock( return_value="{0} converter address".format(token_address)) else: # add 'transfer' and 'balanceOf' methods to token address # this token instance operates as an IRC token interface score token_address.transfer = PropertyMock() token_address.balanceOf = PropertyMock(return_value=0) return token_address with patch_property(IconScoreBase, 'msg', Message(self.network_owner)): # the amount is set to 0. in this unit test, do not check the exact return value # just check whether if specific methods have been called or not amount = 0 min_return = 10 self.network_score.create_interface_score = create_interface_score_mock actual_to_token, actual_amount = self.network_score.\ _convert_by_path(converted_path, amount, min_return, for_address) self.assertEqual(converted_path[-1], actual_to_token) self.assertEqual(amount, actual_amount) # check flexible token's 'getOwner' method have been called ( flexible token's index is 1, 3 ) for i, flexible_token in enumerate(converted_path): if i % 2 == 1: flexible_token.getOwner.assert_called_once() # check 'from' token's 'transfer' method have been called ( from token's index is 0, 2 ) for i, from_token in enumerate(converted_path): if i % 2 == 0 and i != len(converted_path) - 1: data = dict() data["toToken"] = str(converted_path[i + 2]) # in the last converting, minReturn should be user inputted data (10) data["minReturn"] = min_return if i == len( converted_path) - 3 else 1 encoded_data = json_dumps(data).encode() from_token.transfer.assert_called_once_with( "{0} converter address".format(converted_path[i + 1]), amount, encoded_data) # check 'to' token's getBalanceOf method have been called ( to token's index is 2, 4 ) for i, from_token in enumerate(converted_path): if i % 2 == 0 and i != 0: # 'balanceOf' method should be called twice from_token.balanceOf.assert_called()
def test_block_v0_1a_from_dict(self): version = "0.1a" prev_block_hash = bytes.fromhex( "f578312788010043e7a0b959e0c0dbca87c4e7a90331ac59a91fb2fdb62c8640") merkle_tree_root_hash = bytes.fromhex( "30cdeb912b4acdac5c2cdd885983648c366ec0d99ce99a841bb4620f34f9b5c9") timestamp = 1537429228235545 block_hash = bytes.fromhex( "15bbaed5a869738b4c40614a4134f666057de1dd492234d7aa3e06f05a5e85ca") height = 59669 peer_id = Address.from_string( "hx667e748e93a5a4e1d61c92c482577888e8c35c9d") commit_state = bytes.fromhex( "4b57f72f29ebdf5d5543e12ea63e684ab6636c53ca24600f0208e410f0311447") confirmed_transaction_list = [{ "from": "hxeb56a51667eb0491bd1308426865193a9684908a", "to": "hx5c328b010e4ef0f81670ef48eb1b903aac1443e2", "value": "0x8ac7230489e80000", "version": "0x3", "nid": "0x1", "stepLimit": "0x186a0", "timestamp": "0x57648a309f940", "signature": "KglKpRzx1kRCmfOEnU7ltIa2PFaJDhHElowNFxDeXgNP7ksttPCT3fnSR4PpoPpkVVh3wprQVZr+KCPK6r7uRwA=", "txHash": "30cdeb912b4acdac5c2cdd885983648c366ec0d99ce99a841bb4620f34f9b5c9", }] block_dict = { "version": version, "prev_block_hash": prev_block_hash.hex(), "merkle_tree_root_hash": merkle_tree_root_hash.hex(), "time_stamp": timestamp, "confirmed_transaction_list": confirmed_transaction_list, "block_hash": block_hash.hex(), "height": height, "peer_id": str(peer_id), "signature": "M97tADsivw0qtzD0qJUDjIc/ki6Zf5HatoAnOTgpi2dNmP5WvJccAVpD86mjxxNOtdnFnO009iwnvw6yU0RBNAA=", "commit_state": { "icon_dex": commit_state.hex() }, } loopchain_block = LoopchainBlock.from_dict(block_dict) self.assertEqual(prev_block_hash, loopchain_block.prev_block_hash) self.assertEqual(timestamp, loopchain_block.timestamp) self.assertEqual(block_hash, loopchain_block.block_hash) self.assertEqual(height, loopchain_block.height)
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 from_dict(cls, data: dict) -> 'Node': _id = data["id"] if isinstance(_id, str): address: 'Address' = Address.from_string(_id) elif isinstance(_id, Address): address: 'Address' = _id else: raise Exception(f"Invalid data type: (data['id']){type(_id)}") p2p_endpoint: str = data["p2pEndpoint"] return Node(address, p2p_endpoint)
def setUp(self): self.db_name = 'engine.db' db = ContextDatabase.from_path(self.db_name) self.engine = IcxEngine() self.from_ = Address.from_string('hx' + 'a' * 40) self.to = Address.from_string('hx' + 'b' * 40) self.genesis_address = Address.from_string('hx' + '0' * 40) self.fee_treasury_address = Address.from_string('hx' + '1' * 40) self.total_supply = 10**20 # 100 icx self.context = IconScoreContext(IconScoreContextType.DIRECT) icx_storage = IcxStorage(db) self.engine.open(icx_storage) self.engine.init_account(self.context, AccountType.GENESIS, 'genesis', self.genesis_address, self.total_supply) self.engine.init_account(self.context, AccountType.TREASURY, 'treasury', self.fee_treasury_address, 0)
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()