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()
