def genesis_invoke(self, block: Block) -> ('Block', dict):
method = "icx_sendTransaction"
transactions = []
for tx in block.body.transactions.values():
hash_version = conf.CHANNEL_OPTION[
ChannelProperty().name]["genesis_tx_hash_version"]
tx_serializer = TransactionSerializer.new(tx.version, hash_version)
transaction = {
"method": method,
"params": {
"txHash": tx.hash.hex()
},
"genesisData": tx_serializer.to_full_data(tx)
}
transactions.append(transaction)
request = {
'block': {
'blockHeight': block.header.height,
'blockHash': block.header.hash.hex(),
'timestamp': block.header.timestamp
},
'transactions': transactions
}
request = convert_params(request, ParamType.invoke)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
response = stub.sync_task().invoke(request)
response_to_json_query(response)
block_builder = BlockBuilder.from_new(block)
block_builder.commit_state = {
ChannelProperty().name: response['stateRootHash']
}
new_block = block_builder.build()
return new_block, response["txResults"]
async def icx_sendTransaction(**kwargs):
if RestProperty().node_type == conf.NodeType.CitizenNode:
return await redirect_request_to_rs(
kwargs, RestProperty().rs_target)
request = make_request("icx_sendTransaction", kwargs)
icon_stub = StubCollection().icon_score_stubs[conf.LOOPCHAIN_DEFAULT_CHANNEL]
response = await icon_stub.async_task().validate_transaction(request)
response_to_json_query(response)
channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL
channel_stub = StubCollection().channel_stubs[channel_name]
response_code, tx_hash = \
await channel_stub.async_task().create_icx_tx(kwargs)
if response_code != message_code.Response.success:
raise GenericJsonRpcServerError(
code=JsonError.INVALID_REQUEST,
message=message_code.responseCodeMap[response_code][1],
http_status=status.HTTP_BAD_REQUEST
)
if tx_hash is None:
raise GenericJsonRpcServerError(
code=JsonError.INVALID_REQUEST,
message='txHash is None',
http_status=status.HTTP_BAD_REQUEST
)
return convert_params(tx_hash, ParamType.send_tx_response)
def score_invoke(self, _block: Block) -> dict or None:
if conf.USE_EXTERNAL_SCORE:
method = "icx_sendTransaction"
transactions = []
for tx in _block.confirmed_transaction_list:
data = tx.icx_origin_data
transaction = {"method": method, "params": data}
transactions.append(transaction)
request = {
'block': {
'blockHeight': _block.height,
'blockHash': _block.block_hash,
'prevBlockHash': _block.prev_block_hash,
'timestamp': _block.time_stamp
},
'transactions': transactions
}
request = convert_params(request, ParamType.invoke)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
response = stub.sync_task().invoke(request)
response_to_json_query(response)
_block.commit_state[
ChannelProperty().name] = response['stateRootHash']
return response["txResults"]
else:
stub = StubCollection().score_stubs[ChannelProperty().name]
response = stub.sync_task().score_invoke(_block)
if response.code == message_code.Response.success:
commit_state = pickle.loads(response.object)
_block.commit_state = commit_state
return json.loads(response.meta)
return None
async def icx_sendTransaction(**kwargs):
if RestProperty().node_type == conf.NodeType.CitizenNode:
return await redirect_request_to_rs(kwargs,
RestProperty().rs_target,
conf.ApiVersion.v2.name)
request = make_request("icx_sendTransaction", kwargs,
ParamType.send_tx)
icon_stub = StubCollection().icon_score_stubs[
conf.LOOPCHAIN_DEFAULT_CHANNEL]
response = await icon_stub.async_task().validate_transaction(request)
response_to_json_query(response)
channel_inner_tasks = StubCollection().channel_stubs[
conf.LOOPCHAIN_DEFAULT_CHANNEL]
code, tx_hash = await channel_inner_tasks.async_task().create_icx_tx(
kwargs)
response_data = {'response_code': code}
if code != message_code.Response.success:
response_data['message'] = message_code.responseCodeMap[code][1]
else:
response_data['tx_hash'] = tx_hash
util.logger.spam(f"response_data: ({response_data})")
return response_data
def __request_roll_back(self):
target_block = self.blockchain.find_block_by_hash32(
self.blockchain.last_block.header.prev_hash)
if not self.blockchain.check_rollback_possible(target_block):
util.logger.warning(
f"The request cannot be rolled back to the target block({target_block})."
)
return
request_origin = {
'blockHeight': target_block.header.height,
'blockHash': target_block.header.hash.hex_0x()
}
request = convert_params(request_origin, ParamType.roll_back)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
util.logger.debug(f"Rollback request({request})")
response: dict = cast(dict, stub.sync_task().rollback(request))
response_to_json_query(response)
result_height = response.get("blockHeight")
if hex(target_block.header.height) == result_height:
util.logger.info(f"Rollback Success")
self.blockchain.roll_back(target_block)
self.rebuild_block()
else:
util.logger.warning(f"{response}")
def request_rollback(self) -> bool:
"""Request block data rollback behind to 1 block
:return: if rollback success return True, else return False
"""
target_block = self.blockchain.find_block_by_hash32(self.blockchain.last_block.header.prev_hash)
if not self.blockchain.check_rollback_possible(target_block):
util.logger.warning(f"The request cannot be rollback to the target block({target_block}).")
return False
request_origin = {
'blockHeight': target_block.header.height,
'blockHash': target_block.header.hash.hex_0x()
}
request = convert_params(request_origin, ParamType.roll_back)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
util.logger.debug(f"Rollback request({request})")
response: dict = cast(dict, stub.sync_task().rollback(request))
try:
response_to_json_query(response)
except GenericJsonRpcServerError as e:
util.logger.warning(f"response error = {e}")
else:
result_height = response.get("blockHeight")
if hex(target_block.header.height) == result_height:
util.logger.info(f"Rollback Success. result height = {result_height}")
self.blockchain.rollback(target_block)
self.rebuild_block()
return True
util.logger.warning(f"Rollback Fail. response = {response}")
return False
def score_invoke(self, _block: Block) -> dict or None:
method = "icx_sendTransaction"
transactions = []
for tx in _block.body.transactions.values():
tx_serializer = TransactionSerializer.new(tx.version, self.block_manager.get_blockchain().tx_versioner)
transaction = {
"method": method,
"params": tx_serializer.to_full_data(tx)
}
transactions.append(transaction)
request = {
'block': {
'blockHeight': _block.header.height,
'blockHash': _block.header.hash.hex(),
'prevBlockHash': _block.header.prev_hash.hex() if _block.header.prev_hash else '',
'timestamp': _block.header.timestamp
},
'transactions': transactions
}
request = convert_params(request, ParamType.invoke)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
response = stub.sync_task().invoke(request)
response_to_json_query(response)
block_builder = BlockBuilder.from_new(_block, self.__block_manager.get_blockchain().tx_versioner)
block_builder.commit_state = {
ChannelProperty().name: response['stateRootHash']
}
new_block = block_builder.build()
return new_block, response["txResults"]
async def icx_getScoreApi(**kwargs):
channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL
score_stub = StubCollection().icon_score_stubs[channel_name]
method = 'icx_getScoreApi'
request = make_request(method, kwargs)
response = await score_stub.async_task().query(request)
response_to_json_query(response)
return response
def genesis_invoke(self, block: Block) -> ('Block', dict):
method = "icx_sendTransaction"
transactions = []
for tx in block.body.transactions.values():
tx_serializer = TransactionSerializer.new(
tx.version,
self.block_manager.get_blockchain().tx_versioner)
transaction = {
"method": method,
"params": {
"txHash": tx.hash.hex()
},
"genesisData": tx_serializer.to_full_data(tx)
}
transactions.append(transaction)
request = {
'block': {
'blockHeight': block.header.height,
'blockHash': block.header.hash.hex(),
'timestamp': block.header.timestamp
},
'transactions': transactions
}
request = convert_params(request, ParamType.invoke)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
response = stub.sync_task().invoke(request)
response_to_json_query(response)
tx_receipts = response["txResults"]
block_builder = BlockBuilder.from_new(
block,
self.block_manager.get_blockchain().tx_versioner)
block_builder.reset_cache()
block_builder.peer_id = block.header.peer_id
block_builder.signature = block.header.signature
block_builder.commit_state = {
ChannelProperty().name: response['stateRootHash']
}
block_builder.state_hash = Hash32(
bytes.fromhex(response['stateRootHash']))
block_builder.receipts = tx_receipts
block_builder.reps = self.get_rep_ids()
new_block = block_builder.build()
return new_block, tx_receipts
async def icx_getTotalSupply(**kwargs):
channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL
method = 'icx_getTotalSupply'
request = make_request(method, kwargs, ParamType.get_total_supply)
stub = StubCollection().icon_score_stubs[channel_name]
response = await stub.async_task().query(request)
return response_to_json_query(response, is_convert=True)
def genesis_invoke(self, block: Block) -> dict or None:
if util.channel_use_icx(ChannelProperty().name):
method = "icx_sendTransaction"
transactions = []
for tx in block.confirmed_transaction_list:
transaction = {
"method": method,
"params": {
"txHash": tx.tx_hash
},
"genesisData": tx.genesis_origin_data
}
transactions.append(transaction)
request = {
'block': {
'blockHeight': block.height,
'blockHash': block.block_hash,
'timestamp': block.time_stamp
},
'transactions': transactions
}
request = convert_params(request, ParamType.invoke)
stub = StubCollection().icon_score_stubs[ChannelProperty().name]
response = stub.sync_task().invoke(request)
response_to_json_query(response)
block.commit_state[ChannelProperty().name] = response['stateRootHash']
return response["txResults"]
else:
block_object = pickle.dumps(block)
stub = StubCollection().score_stubs[ChannelProperty().name]
response = stub.sync_task().genesis_invoke(block_object)
if response.code == message_code.Response.success:
return json.loads(response.meta)
return None
