def debug_make_and_req_block(
self,
tx_list: list,
prev_block_generator: Optional['Address'] = None,
prev_block_validators: Optional[List['Address']] = None,
prev_block_votes: Optional[List[Tuple['Address', int]]] = None,
block: 'Block' = None) -> tuple:
# Prevent a base transaction from being added to the original tx_list
tx_list = copy.copy(tx_list)
if block is None:
block_height: int = self._block_height + 1
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us,
self._prev_block_hash, 0)
context = IconScoreContext(IconScoreContextType.DIRECT)
context._inv_container = context.engine.inv.inv_container
context._term = context.engine.prep.term
is_block_editable = False
if context.is_decentralized():
is_block_editable = True
tx_results, state_root_hash, added_transactions, next_preps = \
self.icon_service_engine.invoke(block=block,
tx_requests=tx_list,
prev_block_generator=prev_block_generator,
prev_block_validators=prev_block_validators,
prev_block_votes=prev_block_votes,
is_block_editable=is_block_editable)
return block, tx_results, state_root_hash, added_transactions, next_preps
def make_and_req_block_for_2_depth_invocation(
self,
tx_list: list,
prev_block: 'Block',
prev_block_generator: Optional['Address'] = None,
prev_block_validators: Optional[List['Address']] = None,
prev_block_votes: Optional[List[Tuple['Address', int]]] = None,
) -> Tuple['Block', List[bytes]]:
block_height: int = prev_block.height + 1
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us, prev_block.hash,
0)
context = IconScoreContext(IconScoreContextType.DIRECT)
is_block_editable = False
if context.is_decentralized():
is_block_editable = True
tx_results, state_root_hash, added_transactions, next_preps = \
self.icon_service_engine.invoke(block=block,
tx_requests=tx_list,
prev_block_generator=prev_block_generator,
prev_block_validators=prev_block_validators,
prev_block_votes=prev_block_votes,
is_block_editable=is_block_editable)
self.add_tx_result(tx_results)
return block, self.get_hash_list_from_tx_list(tx_list)
def _make_and_req_block_for_issue_test(
self,
tx_list: list,
block_height: int = None,
prev_block_generator: Optional['Address'] = None,
prev_block_validators: Optional[List['Address']] = None,
prev_block_votes: Optional[List[Tuple['Address', int]]] = None,
is_block_editable=False,
cumulative_fee: int = 0) -> Tuple['Block', List[bytes]]:
if block_height is None:
block_height: int = self._block_height + 1
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us,
self._prev_block_hash, cumulative_fee)
tx_results, _, added_transactions, next_preps = \
self.icon_service_engine.invoke(block=block,
tx_requests=tx_list,
prev_block_generator=prev_block_generator,
prev_block_validators=prev_block_validators,
prev_block_votes=prev_block_votes,
is_block_editable=is_block_editable)
self.add_tx_result(tx_results)
return block, self.get_hash_list_from_tx_list(tx_list)
def _create_invalid_block(self, block_height: int = None) -> 'Block':
if block_height is None:
block_height: int = self._block_height
block_hash = create_block_hash()
timestamp_us = create_timestamp()
return Block(block_height, block_hash, timestamp_us, self._prev_block_hash, 0)
def _make_score_call_tx(self,
addr_from: Optional['Address'],
addr_to: 'Address',
method: str,
params: dict,
value: int = 0):
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"value": value,
"stepLimit": self._step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "call",
"data": {
"method": method,
"params": params
}
}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {'method': method, 'params': request_params}
self.icon_service_engine.validate_transaction(tx)
return tx
def _make_icx_send_tx(self,
addr_from: Optional['Address'],
addr_to: Union['Address', 'MalformedAddress'],
value: int,
disable_pre_validate: bool = False,
support_v2: bool = False):
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"from": addr_from,
"to": addr_to,
"value": value,
"stepLimit": self._step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature
}
if support_v2:
request_params["fee"] = 10**16
else:
request_params["version"] = self._version
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {'method': method, 'params': request_params}
if not disable_pre_validate:
self.icon_service_engine.validate_transaction(tx)
return tx
def make_and_req_block(self,
tx_list: list,
block_height: int = None,
prev_block_generator: Optional['Address'] = None,
prev_block_validators: Optional[List['Address']] = None,
prev_block_votes: Optional[List[Tuple['Address', int]]] = None,
block_hash: bytes = None) \
-> Tuple['Block', List[bytes]]:
if block_height is None:
block_height: int = self._block_height + 1
if block_hash is None:
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us,
self._prev_block_hash, 0)
context = IconScoreContext(IconScoreContextType.DIRECT)
context._inv_container = context.engine.inv.inv_container
context._term = context.engine.prep.term
is_block_editable = False
if context.is_decentralized():
is_block_editable = True
tx_results, state_root_hash, added_transactions, next_preps, is_shutdown = \
self.icon_service_engine.invoke(block=block,
tx_requests=tx_list,
prev_block_generator=prev_block_generator,
prev_block_validators=prev_block_validators,
prev_block_votes=prev_block_votes,
is_block_editable=is_block_editable)
self.add_tx_result(tx_results)
return block, self.get_hash_list_from_tx_list(tx_list)
def create_deploy_score_tx(self,
score_root: str,
score_name: str,
from_: Union['EOAAccount', 'Address', None],
to_: Union['EOAAccount', 'Address'],
deploy_params: dict = None,
timestamp_us: int = None,
data: bytes = None,
is_sys: bool = False,
pre_validation_enabled: bool = True,
step_limit: int = DEFAULT_DEPLOY_STEP_LIMIT) -> dict:
addr_from: Optional['Address'] = self._convert_address_from_address_type(from_)
addr_to: 'Address' = self._convert_address_from_address_type(to_)
if deploy_params is None:
deploy_params = {}
score_path = get_score_path(score_root, score_name)
if is_sys:
deploy_data = {'contentType': 'application/tbears', 'content': score_path, 'params': deploy_params}
else:
if data is None:
mz = InMemoryZip()
mz.zip_in_memory(score_path)
data = f'0x{mz.data.hex()}'
else:
data = f'0x{bytes.hex(data)}'
deploy_data = {'contentType': 'application/zip', 'content': data, 'params': deploy_params}
if timestamp_us is None:
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"stepLimit": step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "deploy",
"data": deploy_data
}
origin_params = {'params': self.make_origin_params(request_params)}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
if pre_validation_enabled:
self.icon_service_engine.validate_transaction(tx, origin_params)
return tx
def _make_deploy_tx(self,
score_root: str,
score_name: str,
addr_from: Union['Address', None],
addr_to: 'Address',
deploy_params: dict = None,
timestamp_us: int = None,
data: bytes = None,
is_sys: bool = False):
if deploy_params is None:
deploy_params = {}
score_path = get_score_path(score_root, score_name)
if is_sys:
deploy_data = {
'contentType': 'application/tbears',
'content': score_path,
'params': deploy_params
}
else:
if data is None:
mz = InMemoryZip()
mz.zip_in_memory(score_path)
data = f'0x{mz.data.hex()}'
else:
data = f'0x{bytes.hex(data)}'
deploy_data = {
'contentType': 'application/zip',
'content': data,
'params': deploy_params
}
if timestamp_us is None:
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"stepLimit": self._step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "deploy",
"data": deploy_data
}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {'method': method, 'params': request_params}
self.icon_service_engine.validate_transaction(tx)
return tx
def _genesis_invoke(self) -> list:
tx_hash = create_tx_hash()
timestamp_us = create_timestamp()
request_params = {
'txHash': tx_hash,
'version': self._version,
'timestamp': timestamp_us
}
tx = {
'method': 'icx_sendTransaction',
'params': request_params,
'genesisData': {
"accounts": [
{
"name": "genesis",
"address": self.genesis,
"balance": 100 * self._icx_factor
},
{
"name": "fee_treasury",
"address": self._fee_treasury,
"balance": 0
},
{
"name": "owner1",
"address": self.owner1,
"balance": 100 * self._icx_factor
},
{
"name": "owner2",
"address": self.owner2,
"balance": 100 * self._icx_factor
},
{
"name": "owner3",
"address": self.owner3,
"balance": 100 * self._icx_factor
},
]
},
}
block_hash = create_block_hash()
block = Block(self._block_height, block_hash, timestamp_us, None)
invoke_response, state_root_hash, added_transactions, next_preps = \
self.icon_service_engine.invoke(block=block,
tx_requests=[tx])
self.icon_service_engine.commit(block.height, block.hash, None)
self._block_height += 1
self._prev_block_hash = block_hash
return invoke_response
def _create_base_transaction(self):
context = IconScoreContext(IconScoreContextType.DIRECT)
context._preps = context.engine.prep.preps.copy(mutable=True)
context._term = context.engine.prep.term.copy()
block_height: int = self._block_height
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us, self._prev_block_hash, 0)
context.block = block
transaction = BaseTransactionCreator.create_base_transaction(context)
return transaction
def _make_and_req_block(self,
tx_list: list,
block_height: int = None) -> tuple:
if block_height is None:
block_height: int = self._block_height
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us,
self._prev_block_hash)
invoke_response, _ = self.icon_service_engine.invoke(block, tx_list)
return block, invoke_response
def _make_and_req_block(self,
tx_list: list,
block_height: int = None) -> tuple:
if block_height is None:
block_height: int = self._block_height
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us,
self._prev_block_hash)
tx_results, state_root_hash, added_transactions, next_preps = \
self.icon_service_engine.invoke(block=block,
tx_requests=tx_list)
return block, tx_results
def block_batch():
block = Block(block_height=1,
block_hash=create_block_hash(),
timestamp=create_timestamp(),
prev_hash=create_block_hash(),
cumulative_fee=5)
block_batch: 'BlockBatch' = BlockBatch(block)
block_batch.block = block
tx_batch: 'TransactionBatch' = TransactionBatch()
for i, data in enumerate(DATA_LIST):
tx_batch[create_hash_256()] = TransactionBatchValue(data, True, i)
block_batch.update(tx_batch)
return block_batch
def _make_issue_info(self) -> tuple:
context = IconScoreContext(IconScoreContextType.DIRECT)
context._preps = context.engine.prep.preps.copy(mutable=True)
context._term = context.engine.prep.term.copy()
block_height: int = self._block_height
block_hash = create_block_hash()
timestamp_us = create_timestamp()
block = Block(block_height, block_hash, timestamp_us, self._prev_block_hash, 0)
context.block = block
issue_data = IconScoreContext.engine.issue.create_icx_issue_info(context)
total_issue_amount = 0
for group_dict in issue_data.values():
if "value" in group_dict:
total_issue_amount += group_dict["value"]
return issue_data, total_issue_amount
def create_deposit_tx(self,
from_: Union['EOAAccount', 'Address', None],
to_: 'Address',
action: str,
params: dict,
value: int = 0,
pre_validation_enabled: bool = True,
step_limit: int = DEFAULT_BIG_STEP_LIMIT) -> dict:
addr_from: Optional['Address'] = self._convert_address_from_address_type(from_)
addr_to: 'Address' = self._convert_address_from_address_type(to_)
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"value": value,
"stepLimit": step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "deposit",
"data": {
"action": action,
}
}
origin_params = {
'params': self.make_origin_params(request_params)
}
for k, v in params.items():
request_params["data"][k] = v
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
if pre_validation_enabled:
self.icon_service_engine.validate_transaction(tx, origin_params)
return tx
def create_score_call_tx(self,
from_: Union['EOAAccount', 'Address', None],
to_: 'Address',
func_name: str,
params: Optional[dict] = None,
value: int = 0,
pre_validation_enabled: bool = True,
step_limit: int = DEFAULT_BIG_STEP_LIMIT) -> dict:
from_: Optional['Address'] = self._convert_address_from_address_type(from_)
if params is None:
params: dict = {}
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": from_,
"to": to_,
"value": value,
"stepLimit": step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "call",
"data": {
"method": func_name,
"params": params
}
}
origin_params = {
'params': self.make_origin_params(request_params)
}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
if pre_validation_enabled:
self.icon_service_engine.validate_transaction(tx, origin_params)
return tx
def _make_base_tx(self, data: dict):
timestamp_us = create_timestamp()
request_params = {
"version": self._version,
"timestamp": timestamp_us,
"dataType": "base",
"data": data
}
method = 'icx_sendTransaction'
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
return tx
def _genesis_invoke(self) -> tuple:
tx_hash = create_tx_hash()
timestamp_us = create_timestamp()
request_params = {
'txHash': tx_hash,
'version': self._version,
'timestamp': timestamp_us
}
tx = {
'method': 'icx_sendTransaction',
'params': request_params,
'genesisData': {
"accounts": [
{
"name": "genesis",
"address": self._genesis,
"balance": 0
},
{
"name": "fee_treasury",
"address": self._fee_treasury,
"balance": 0
},
{
"name": "_admin",
"address": self._admin.address,
"balance": icx_to_loop(TOTAL_SUPPLY)
}
]
},
}
block_hash = create_block_hash()
block = Block(self._block_height + 1, block_hash, timestamp_us, None, 0)
invoke_response: tuple = self.icon_service_engine.invoke(
block,
[tx]
)
self.icon_service_engine.commit(block.height, block.hash, block.hash)
self._block_height += 1
self._prev_block_hash = block_hash
return invoke_response
def create_transfer_icx_tx(self,
from_: Union['EOAAccount', 'Address', None],
to_: Union['EOAAccount', 'Address', 'MalformedAddress'],
value: int,
disable_pre_validate: bool = False,
support_v2: bool = False,
step_limit: int = DEFAULT_STEP_LIMIT) -> dict:
addr_from: Optional['Address'] = self._convert_address_from_address_type(from_)
addr_to: Optional['Address', 'MalformedAddress'] = self._convert_address_from_address_type(to_)
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"from": addr_from,
"to": addr_to,
"value": value,
"stepLimit": step_limit,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature
}
if support_v2:
request_params["fee"] = 10 ** 16
else:
request_params["version"] = self._version
origin_params = {
'params': self.make_origin_params(request_params)
}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
if not disable_pre_validate:
self.icon_service_engine.validate_transaction(tx, origin_params)
return tx
def create_message_tx(self,
from_: Union['EOAAccount', 'Address', None],
to_: Union['EOAAccount', 'Address', 'MalformedAddress'],
data: bytes = None,
value: int = 0,
pre_validation_enabled: bool = False) -> dict:
addr_from: Optional['Address'] = self._convert_address_from_address_type(from_)
addr_to: Optional['Address', 'MalformedAddress'] = self._convert_address_from_address_type(to_)
timestamp_us = create_timestamp()
nonce = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"value": value,
"stepLimit": DEFAULT_BIG_STEP_LIMIT,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "message",
"data": '0x' + data.hex(),
}
origin_params = {
'params': self.make_origin_params(request_params)
}
method = 'icx_sendTransaction'
# Inserts txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {
'method': method,
'params': request_params
}
if pre_validation_enabled:
self.icon_service_engine.validate_transaction(tx, origin_params)
return tx
def _create_invalid_deploy_tx(self,
from_: Union['EOAAccount', 'Address', None],
to_: Union['EOAAccount', 'Address'],
content: Any = None):
addr_from: Optional[
'Address'] = self._convert_address_from_address_type(from_)
addr_to: 'Address' = self._convert_address_from_address_type(to_)
deploy_params: dict = {}
deploy_data: dict = {
'contentType': 'application/zip',
'content': content,
'params': deploy_params
}
timestamp_us: int = create_timestamp()
nonce: int = 0
request_params = {
"version": self._version,
"from": addr_from,
"to": addr_to,
"stepLimit": DEFAULT_DEPLOY_STEP_LIMIT,
"timestamp": timestamp_us,
"nonce": nonce,
"signature": self._signature,
"dataType": "deploy",
"data": deploy_data
}
method = 'icx_sendTransaction'
# Insert txHash into request params
request_params['txHash'] = create_tx_hash()
tx = {'method': method, 'params': request_params}
return tx
def _create_dummy_block_by_height(self, height: int):
block_hash = create_block_hash()
prev_block_hash = create_block_hash()
timestamp_us = create_timestamp()
return Block(height, block_hash, timestamp_us, prev_block_hash, 0)
