Example 1 with NodeWrapper
use of org.aion.zero.impl.sync.NodeWrapper in project aion by aionnetwork.
the class ApiWeb3Aion method priv_peers.
/* -------------------------------------------------------------------------
* private debugging APIs
* Reasoning for not adding this to conventional web3 calls is so
* we can freely change the responses without breaking compatibility
*/
public RpcMsg priv_peers() {
Map<Integer, NodeWrapper> activeNodes = this.ac.getAionHub().getActiveNodes();
JSONArray peerList = new JSONArray();
for (NodeWrapper node : activeNodes.values()) {
JSONObject n = new JSONObject();
n.put("idShort", node.getIdShort());
n.put("id", new String(node.getId()));
n.put("idHash", node.getIdHash());
n.put("version", node.getBinaryVersion());
n.put("blockNumber", node.getBestBlockNumber());
n.put("totalDifficulty", node.getTotalDifficulty());
JSONObject network = new JSONObject();
network.put("remoteAddress", node.getIpStr() + ":" + node.getPort());
n.put("network", network);
n.put("latestTimestamp", node.getTimestamp());
// generate a date corresponding to UTC date time (not local)
String utcTimestampDate = Instant.ofEpochMilli(node.getTimestamp()).atOffset(ZoneOffset.UTC).toString();
n.put("latestTimestampUTC", utcTimestampDate);
n.put("version", node.getBinaryVersion());
peerList.put(n);
}
return new RpcMsg(peerList);
}
Also used :
BigInteger(java.math.BigInteger)
JSONObject(org.json.JSONObject)
JSONArray(org.json.JSONArray)
NodeWrapper(org.aion.zero.impl.sync.NodeWrapper)
Hex.toHexString(org.aion.util.conversions.Hex.toHexString)
Example 2 with NodeWrapper
use of org.aion.zero.impl.sync.NodeWrapper in project aion by aionnetwork.
the class ApiAion0 method process.
public byte[] process(byte[] request, byte[] socketId) {
if (request == null || (request.length < this.getApiHeaderLen())) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_header_len_VALUE);
}
byte[] msgHash = ApiUtil.getApiMsgHash(request);
if (request[0] < this.getApiVersion()) {
return msgHash == null ? ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_api_version_VALUE) : ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_api_version_VALUE, msgHash);
}
short service = (short) request[1];
switch((short) request[2]) {
// General Module
case Message.Funcs.f_protocolVersion_VALUE:
{
if (service != Message.Servs.s_net_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
// TODO : create query API for every module
Message.rsp_protocolVersion rsp = Message.rsp_protocolVersion.newBuilder().setApi(String.valueOf(this.getApiVersion())).setDb(AionHub.getRepoVersion()).setKernel(Version.KERNEL_VERSION).setMiner(EquihashMiner.VERSION).setNet(this.p2pProtocolVersion()).setTxpool(this.ac.getAionHub().getPendingState().getVersion()).setVm("0.1.0").build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_minerAddress_VALUE:
{
if (service != Message.Servs.s_wallet_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
String cb = this.getCoinbase();
if (cb == null) {
LOG.debug("ApiAion0.process.coinbase - null coinbase");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_wallet_nullcb_VALUE);
}
Message.rsp_minerAddress rsp = Message.rsp_minerAddress.newBuilder().setMinerAddr(ByteString.copyFrom(StringUtils.StringHexToByteArray(cb))).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_contractDeploy_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE, msgHash);
}
Message.req_contractDeploy req;
byte[] data = parseMsgReq(request, msgHash);
ApiTxResponse result;
try {
req = Message.req_contractDeploy.parseFrom(data);
// TODO: the client api should send server binary code directly
// instead of str format like "0xhex".!
byte[] bytes = req.getData().toByteArray();
if (bytes == null || bytes.length <= 4) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_ct_bytecode_VALUE, msgHash);
}
ArgTxCall params = new ArgTxCall(new AionAddress(req.getFrom().toByteArray()), null, Hex.decode(new String(bytes).substring(2)), BigInteger.ZERO, BigInteger.ZERO, req.getNrgLimit(), req.getNrgPrice(), null);
LOG.debug("ApiAion0.process.ContractDeploy - ArgsTxCall: [{}] ", params.toString());
result = this.createContract(params);
if (!result.isFail()) {
getMsgIdMapping().put(ByteArrayWrapper.wrap(result.getTxHash()), new AbstractMap.SimpleEntry<>(ByteArrayWrapper.wrap(msgHash), ByteArrayWrapper.wrap(socketId)));
if (LOG.isDebugEnabled()) {
LOG.debug("ApiAion0.process.ContractDeploy - msgIdMapping.put: [{}] ", ByteArrayWrapper.wrap(result.getTxHash()).toString());
}
Message.rsp_contractDeploy rsp = Message.rsp_contractDeploy.newBuilder().setContractAddress(ByteString.copyFrom(result.getContractAddress().toByteArray())).setTxHash(ByteString.copyFrom(result.getTxHash())).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_tx_Recved_VALUE, msgHash);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} else {
return processTxFail(result, msgHash);
}
} catch (Exception e) {
LOG.error("ApiAion0.process.ContractDeploy exception [{}] ", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE, msgHash);
}
}
// Authenication Module
case Message.Funcs.f_accounts_VALUE:
{
if (service != Message.Servs.s_wallet_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
// noinspection unchecked
List<String> accounts = this.getAccounts();
ArrayList<ByteString> al = new ArrayList<>();
for (String s : accounts) {
al.add(ByteString.copyFrom(StringUtils.StringHexToByteArray(s)));
}
Message.rsp_accounts rsp = Message.rsp_accounts.newBuilder().addAllAccout(al).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_blockNumber_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
Message.rsp_blockNumber rsp = Message.rsp_blockNumber.newBuilder().setBlocknumber(this.getBestBlock().getNumber()).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_unlockAccount_VALUE:
{
if (service != Message.Servs.s_wallet_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
boolean result;
try {
Message.req_unlockAccount req = Message.req_unlockAccount.parseFrom(data);
result = this.unlockAccount(new AionAddress(req.getAccount().toByteArray()), req.getPassword(), req.getDuration());
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.unlockAccount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, (byte) (result ? 0x01 : 0x00));
}
// Transaction Module
case Message.Funcs.f_getBalance_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
BigInteger balance;
try {
Message.req_getBalance req = Message.req_getBalance.parseFrom(data);
AionAddress addr = new AionAddress(req.getAddress().toByteArray());
balance = this.getBalance(addr);
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.getbalance exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
Message.rsp_getBalance rsp = Message.rsp_getBalance.newBuilder().setBalance(ByteString.copyFrom(balance.toByteArray())).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_getNonce_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Message.Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
BigInteger nonce;
try {
Message.req_getNonce req = Message.req_getNonce.parseFrom(data);
AionAddress addr = new AionAddress(req.getAddress().toByteArray());
nonce = this.getNonce(addr);
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAionA0.process.getNonce exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Message.Retcode.r_fail_function_exception_VALUE);
}
Message.rsp_getNonce rsp = Message.rsp_getNonce.newBuilder().setNonce(ByteString.copyFrom(nonce.toByteArray())).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Message.Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_getNrgPrice_VALUE:
{
if (service != Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
long nrg = this.getRecommendedNrgPrice();
try {
Message.rsp_getNrgPrice rsp = Message.rsp_getNrgPrice.newBuilder().setNrgPrice(nrg).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getEnergyPrice exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_compile_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
try {
Message.req_compile req = Message.req_compile.parseFrom(data);
String source = req.getCode();
if (source == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_null_compile_source_VALUE);
}
@SuppressWarnings("unchecked") Map<String, CompiledContr> _contrs = this.contract_compileSolidity(source);
if (_contrs != null && !_contrs.isEmpty()) {
Message.rsp_compile.Builder b = Message.rsp_compile.newBuilder();
for (Entry<String, CompiledContr> entry : _contrs.entrySet()) {
if (entry.getKey().contains("compile-error")) {
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_compile_contract_VALUE);
Message.t_Contract tc = Message.t_Contract.newBuilder().setError(entry.getValue().error).build();
return ApiUtil.combineRetMsg(retHeader, b.putConstracts(entry.getKey(), tc).build().toByteArray());
}
CompiledContr _contr = entry.getValue();
JSONArray abi = new JSONArray();
for (org.aion.solidity.Entry f : _contr.info.abiDefinition) {
abi.put(f.toJSON());
}
Message.t_Contract tc = Message.t_Contract.newBuilder().setCode(_contr.code).setAbiDef(ByteString.copyFrom(abi.toString().getBytes())).setSource(_contr.info.source).build();
b.putConstracts(entry.getKey(), tc);
}
Message.rsp_compile rsp = b.build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} else {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.compile exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Funcs.f_compileSolidityZip_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
try {
Message.req_compileSolidityZip req = Message.req_compileSolidityZip.parseFrom(data);
ByteString zipfile = req.getZipfile();
String entryPoint = req.getEntryPoint();
if (zipfile == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_null_compile_source_VALUE);
}
@SuppressWarnings("unchecked") Map<String, CompiledContr> _contrs = this.contract_compileSolidityZip(zipfile.toByteArray(), entryPoint);
if (_contrs != null && !_contrs.isEmpty()) {
Message.rsp_compile.Builder b = Message.rsp_compile.newBuilder();
for (Entry<String, CompiledContr> entry : _contrs.entrySet()) {
if (entry.getKey().contains("compile-error")) {
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_compile_contract_VALUE);
Message.t_Contract tc = Message.t_Contract.newBuilder().setError(entry.getValue().error).build();
return ApiUtil.combineRetMsg(retHeader, b.putConstracts(entry.getKey(), tc).build().toByteArray());
}
CompiledContr _contr = entry.getValue();
JSONArray abi = new JSONArray();
for (org.aion.solidity.Entry f : _contr.info.abiDefinition) {
abi.put(f.toJSON());
}
Message.t_Contract tc = Message.t_Contract.newBuilder().setCode(_contr.code).setAbiDef(ByteString.copyFrom(abi.toString().getBytes())).setSource(_contr.info.source).build();
b.putConstracts(entry.getKey(), tc);
}
Message.rsp_compile rsp = b.build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} else {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.compile exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_sendTransaction_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE, msgHash);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_sendTransaction req;
ApiTxResponse result;
try {
req = Message.req_sendTransaction.parseFrom(data);
ArgTxCall params = new ArgTxCall(new AionAddress(req.getFrom().toByteArray()), new AionAddress(req.getTo().toByteArray()), req.getData().toByteArray(), new BigInteger(req.getNonce().toByteArray()), new BigInteger(req.getValue().toByteArray()), req.getNrg(), req.getNrgPrice(), null);
result = this.sendTransaction(params);
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.sendTransaction exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE, msgHash);
}
return processSendTxRsp(result, msgHash, socketId);
}
case Message.Funcs.f_getCode_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getCode req;
try {
req = Message.req_getCode.parseFrom(data);
AionAddress to = new AionAddress(req.getAddress().toByteArray());
byte[] code = this.getCode(to);
if (code == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_null_rsp_VALUE);
}
Message.rsp_getCode rsp = Message.rsp_getCode.newBuilder().setCode(ByteString.copyFrom(code)).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getCode exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getTransactionReceipt_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionReceipt req;
try {
req = Message.req_getTransactionReceipt.parseFrom(data);
TxRecpt result = this.getTransactionReceipt(req.getTxHash().toByteArray());
if (result == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_getTxReceipt_null_recp_VALUE);
}
List<Message.t_LgEle> logs = new ArrayList<>();
for (TxRecptLg log : result.logs) {
List<String> al = new ArrayList<>();
Collections.addAll(al, log.topics);
Message.t_LgEle msgLog = Message.t_LgEle.newBuilder().setAddress(ByteString.copyFrom(AddressUtils.wrapAddress(log.address).toByteArray())).setData(ByteString.copyFrom(ByteUtil.hexStringToBytes(log.data))).addAllTopics(al).build();
logs.add(msgLog);
}
Message.rsp_getTransactionReceipt rsp = Message.rsp_getTransactionReceipt.newBuilder().setFrom(ByteString.copyFrom(result.fromAddr.toByteArray())).setBlockNumber(result.blockNumber).setBlockHash(ByteString.copyFrom(result.blockHash != null ? ByteUtil.hexStringToBytes(result.blockHash) : EMPTY_BYTE_ARRAY)).setContractAddress(ByteString.copyFrom(result.contractAddress != null ? ByteUtil.hexStringToBytes(result.contractAddress) : EMPTY_BYTE_ARRAY)).setTxIndex(result.transactionIndex).setTxHash(ByteString.copyFrom(result.transactionHash != null ? ByteUtil.hexStringToBytes(result.transactionHash) : EMPTY_BYTE_ARRAY)).setTo(ByteString.copyFrom(result.toAddr == null ? EMPTY_BYTE_ARRAY : result.toAddr.toByteArray())).setNrgConsumed(result.nrgUsed).setCumulativeNrgUsed(result.cumulativeNrgUsed).addAllLogs(logs).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionReceipt exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_call_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_call req;
try {
req = Message.req_call.parseFrom(data);
AionAddress from = new AionAddress(req.getFrom().toByteArray());
AionAddress to = new AionAddress(req.getTo().toByteArray());
BigInteger value = new BigInteger(req.getValue().toByteArray());
byte[] d = req.getData().toByteArray();
ArgTxCall params = new ArgTxCall(from, to, d, BigInteger.ZERO, value, req.getNrg(), req.getNrgPrice(), null);
Message.rsp_call rsp = Message.rsp_call.newBuilder().setResult(ByteString.copyFrom(this.doCall(params))).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.call exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockByNumber_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockByNumber req;
try {
req = Message.req_getBlockByNumber.parseFrom(data);
long num = req.getBlockNumber();
Block blk = this.getBlock(num);
return createBlockMsg(blk);
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockReward_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockReward req;
BigInteger reward;
try {
req = Message.req_getBlockReward.parseFrom(data);
reward = ac.getBlockchain().calculateBlockRewards(req.getBlockNumber());
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockReward exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
Message.rsp_getBlockReward rsp = Message.rsp_getBlockReward.newBuilder().setReward(ByteString.copyFrom(reward.toByteArray())).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_getBlockByHash_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockByHash req;
try {
req = Message.req_getBlockByHash.parseFrom(data);
byte[] hash = req.getBlockHash().toByteArray();
if (hash == null || hash.length != Hash256.BYTES) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
Block blk = this.getBlockByHash(hash);
return createBlockMsg(blk);
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockByHash exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getTransactionByBlockHashAndIndex_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionByBlockHashAndIndex req;
try {
req = Message.req_getTransactionByBlockHashAndIndex.parseFrom(data);
long txIdx = req.getTxIndex();
byte[] hash = req.getBlockHash().toByteArray();
if (txIdx < -1 || hash == null || hash.length != Hash256.BYTES) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
TransactionWithBlockInfo txInfo = this.getTransactionByBlockHashAndIndex(hash, txIdx);
if (txInfo == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getTransaction rsp = getRsp_getTransaction(txInfo);
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionByBlockHashAndIndex exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getTransactionByBlockNumberAndIndex_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionByBlockNumberAndIndex req;
try {
req = Message.req_getTransactionByBlockNumberAndIndex.parseFrom(data);
long blkNr = req.getBlockNumber();
long txIdx = req.getTxIndex();
if (blkNr < -1 || txIdx < -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
TransactionWithBlockInfo txInfo = this.getTransactionByBlockNumberAndIndex(blkNr, txIdx);
if (txInfo == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getTransaction rsp = getRsp_getTransaction(txInfo);
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionByBlockNumberAndIndex exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockTransactionCountByNumber_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockTransactionCountByNumber req;
try {
req = Message.req_getBlockTransactionCountByNumber.parseFrom(data);
long blkNr = req.getBlockNumber();
if (blkNr < -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
long cnt = this.getBlockTransactionCountByNumber(blkNr);
if (cnt == -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getBlockTransactionCount rsp = Message.rsp_getBlockTransactionCount.newBuilder().setTxCount((int) cnt).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockTransactionCountByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getTransactionCount_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionCount req;
try {
req = Message.req_getTransactionCount.parseFrom(data);
long blkNr = req.getBlocknumber();
AionAddress addr = new AionAddress(req.getAddress().toByteArray());
if (blkNr < -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
long cnt = this.getTransactionCount(addr, blkNr);
if (cnt == -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getTransactionCount rsp = Message.rsp_getTransactionCount.newBuilder().setTxCount((int) cnt).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionCount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockTransactionCountByHash_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionCountByHash req;
try {
req = Message.req_getTransactionCountByHash.parseFrom(data);
byte[] hash = req.getTxHash().toByteArray();
if (hash == null || hash.length != Hash256.BYTES) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
long cnt = this.getTransactionCountByHash(hash);
if (cnt == -1) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getTransactionCount rsp = Message.rsp_getTransactionCount.newBuilder().setTxCount((int) cnt).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionCount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getTransactionByHash_VALUE:
{
if (service != Message.Servs.s_chain_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getTransactionByHash req;
try {
req = Message.req_getTransactionByHash.parseFrom(data);
byte[] txHash = req.getTxHash().toByteArray();
if (txHash == null || txHash.length != this.getTxHashLen()) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
TransactionWithBlockInfo txInfo = this.getTransactionByHash(txHash);
if (txInfo == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
Message.rsp_getTransaction rsp = getRsp_getTransaction(txInfo);
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getTransactionCount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getActiveNodes_VALUE:
{
if (service != Message.Servs.s_net_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
List<NodeWrapper> nodes = new ArrayList<>(this.ac.getAionHub().getActiveNodes().values());
List<Message.t_Node> pl = new ArrayList<>();
try {
for (NodeWrapper n : nodes) {
Message.t_Node node = Message.t_Node.newBuilder().setBlockNumber(n.getBestBlockNumber()).setNodeId(ByteArrayWrapper.wrap(n.getId()).toString()).setRemoteP2PIp(ByteArrayWrapper.wrap(n.getIp()).toString()).build();
pl.add(node);
}
Message.rsp_getActiveNodes rsp = Message.rsp_getActiveNodes.newBuilder().addAllNode(pl).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getActiveNodes exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getStaticNodes_VALUE:
{
if (service != Message.Servs.s_net_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
String[] al = this.getBootNodes();
List<Message.t_Node> nl = new ArrayList<>();
for (String s : al) {
// TODO : get more node info
Message.t_Node n = Message.t_Node.newBuilder().setRemoteP2PIp(s).build();
nl.add(n);
}
try {
Message.rsp_getStaticNodes rsp = Message.rsp_getStaticNodes.newBuilder().addAllNode(nl).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getStaticNodes exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getSolcVersion_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
String ver = this.solcVersion();
try {
Message.rsp_getSolcVersion rsp = Message.rsp_getSolcVersion.newBuilder().setVer(ver).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getSolcVersion exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_isSyncing_VALUE:
{
if (service != Message.Servs.s_net_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
try {
Optional<Long> localBestBlockNumber = this.ac.getLocalBestBlockNumber();
Optional<Long> networkBestBlockNumber = this.ac.getNetworkBestBlockNumber();
// Check that we actually have real values in our hands.
if (!localBestBlockNumber.isPresent()) {
LOG.error("Unable to determine the local node's best block number!");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_VALUE);
}
if (!networkBestBlockNumber.isPresent()) {
LOG.error("Unable to determine the network's best block number!");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_VALUE);
}
SyncInfo syncInfo = this.getSyncInfo(localBestBlockNumber.get(), networkBestBlockNumber.get());
Message.rsp_isSyncing rsp = Message.rsp_isSyncing.newBuilder().setSyncing(!syncInfo.done).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.syncing exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_syncInfo_VALUE:
{
if (service != Message.Servs.s_net_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
Optional<Long> localBestBlockNumber = this.ac.getLocalBestBlockNumber();
Optional<Long> networkBestBlockNumber = this.ac.getNetworkBestBlockNumber();
// Check that we actually have real values in our hands.
if (!localBestBlockNumber.isPresent()) {
LOG.error("Unable to determine the local node's best block number!");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_VALUE);
}
if (!networkBestBlockNumber.isPresent()) {
LOG.error("Unable to determine the network's best block number!");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_VALUE);
}
SyncInfo syncInfo = this.getSyncInfo(localBestBlockNumber.get(), networkBestBlockNumber.get());
try {
Message.rsp_syncInfo rsp = Message.rsp_syncInfo.newBuilder().setChainBestBlock(syncInfo.chainBestBlkNumber).setNetworkBestBlock(syncInfo.networkBestBlkNumber).setSyncing(!syncInfo.done).setMaxImportBlocks(24).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.syncInfo exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_accountCreate_VALUE:
{
if (service != Message.Servs.s_account_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_accountCreate req;
try {
req = Message.req_accountCreate.parseFrom(data);
List<ByteString> addressList = new ArrayList<>();
List<ByteString> pKeyList = new ArrayList<>();
for (int i = 0; i < req.getPasswordList().size() && i < ACCOUNT_CREATE_LIMIT; i++) {
String addr = Keystore.create(req.getPassword(i));
byte[] pKey;
if (req.getPrivateKey()) {
pKey = Keystore.getKey(addr, req.getPassword(i)).getPrivKeyBytes();
if (pKey == null) {
pKey = new byte[] { (byte) 0x0 };
}
pKeyList.add(ByteString.copyFrom(pKey));
}
addressList.add(ByteString.copyFrom(AddressUtils.wrapAddress(addr).toByteArray()));
}
Message.rsp_accountCreate rsp = Message.rsp_accountCreate.newBuilder().addAllAddress(addressList).addAllPrivateKey(pKeyList).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.accountCreate exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_accountLock_VALUE:
{
if (service != Message.Servs.s_wallet_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
if (data == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
boolean result;
try {
Message.req_accountlock req = Message.req_accountlock.parseFrom(data);
result = this.lockAccount(new AionAddress(req.getAccount().toByteArray()), req.getPassword());
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.lockAccount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, (byte) (result ? 0x01 : 0x00));
}
case Message.Funcs.f_userPrivilege_VALUE:
{
if (service != Message.Servs.s_privilege_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_unsupport_api_VALUE);
}
case Message.Funcs.f_mining_VALUE:
{
if (service != Message.Servs.s_mine_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
Message.rsp_mining rsp = Message.rsp_mining.newBuilder().setMining(this.isMining()).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_estimateNrg_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE, msgHash);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_estimateNrg req;
long result;
try {
req = Message.req_estimateNrg.parseFrom(data);
ArgTxCall params = new ArgTxCall(new AionAddress(req.getFrom().toByteArray()), new AionAddress(req.getTo().toByteArray()), req.getData().toByteArray(), BigInteger.ZERO, new BigInteger(req.getValue().toByteArray()), req.getNrg(), req.getNrgPrice(), null);
result = this.estimateNrg(params);
} catch (InvalidProtocolBufferException e) {
LOG.error("ApiAion0.process.estimateNrg exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE, msgHash);
}
Message.rsp_estimateNrg rsp = Message.rsp_estimateNrg.newBuilder().setNrg(result).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_exportAccounts_VALUE:
case Message.Funcs.f_backupAccounts_VALUE:
{
if (service != Message.Servs.s_account_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_exportAccounts req;
try {
req = Message.req_exportAccounts.parseFrom(data);
} catch (Exception e) {
LOG.error("ApiAion0.process.exportAccounts exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
Map<AionAddress, String> addrMap = new HashMap<>();
for (int i = 0; i < req.getKeyFileList().size() && i < ACCOUNT_CREATE_LIMIT; i++) {
addrMap.put(new AionAddress(req.getKeyFile(i).getAddress().toByteArray()), req.getKeyFile(i).getPassword());
}
Map<AionAddress, ByteArrayWrapper> res = ((short) request[2] == Message.Funcs.f_exportAccounts_VALUE) ? Keystore.exportAccount(addrMap) : Keystore.backupAccount(addrMap);
List<ByteString> invalidKey = addrMap.keySet().parallelStream().filter(addr -> res.keySet().parallelStream().noneMatch(ad -> ad.equals(addr))).map(match -> ByteString.copyFrom(match.toByteArray())).collect(Collectors.toList());
List<ByteString> keyBins = res.values().parallelStream().map(key -> ByteString.copyFrom(key.toBytes())).collect(Collectors.toList());
Message.rsp_exportAccounts rsp = Message.rsp_exportAccounts.newBuilder().addAllKeyFile(keyBins).addAllFailedKey(invalidKey).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_importAccounts_VALUE:
{
if (service != Message.Servs.s_account_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_importAccounts req;
try {
req = Message.req_importAccounts.parseFrom(data);
} catch (Exception e) {
LOG.error("ApiAion0.process.importAccount exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
Map<String, String> importKey = req.getPrivateKeyList().parallelStream().collect(Collectors.toMap(Message.t_PrivateKey::getPrivateKey, Message.t_PrivateKey::getPassword));
if (importKey == null) {
LOG.error("ApiAion0.process.importAccount exception: [null importKey]");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
Set<String> res = Keystore.importAccount(importKey);
if (res == null) {
throw new NullPointerException();
}
Message.rsp_importAccounts rsp = Message.rsp_importAccounts.newBuilder().addAllInvalidKey(res).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
case Message.Funcs.f_signedTransaction_VALUE:
case Message.Funcs.f_rawTransaction_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE, msgHash);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_rawTransaction req;
ApiTxResponse result;
try {
req = Message.req_rawTransaction.parseFrom(data);
byte[] encodedTx = req.getEncodedTx().toByteArray();
if (encodedTx == null) {
LOG.error("ApiAion0.process.rawTransaction exception: [null encodedTx]");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
result = this.sendTransaction(encodedTx);
} catch (Exception e) {
LOG.error("ApiAion0.process.rawTransaction exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE, msgHash);
}
return processSendTxRsp(result, msgHash, socketId);
}
case Message.Funcs.f_eventRegister_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_eventRegister req;
try {
req = Message.req_eventRegister.parseFrom(data);
List<String> evtList = new ArrayList<>(req.getEventsList());
if (evtList.isEmpty()) {
LOG.error("ApiNucoNcp.process.eventRegister : [{}]", "empty event list");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
Message.t_FilterCt fltr = req.getFilter();
List<byte[]> accList = new ArrayList<>();
fltr.getAddressesList().forEach(a -> accList.add(a.toByteArray()));
long lv = ByteUtil.byteArrayToLong(socketId);
FltrCt preFc = (FltrCt) installedFilters.get(lv);
if (Optional.ofNullable(preFc).isPresent()) {
preFc.getTopics().forEach(t -> {
if (!fltr.getTopicsList().contains(t)) {
evtList.add(t);
}
});
}
FltrCt fc = new FltrCt(fltr.getContractAddr().toByteArray(), fltr.getTo(), fltr.getFrom(), evtList, accList, fltr.getExpireTime());
installedFilters.put(lv, fc);
Message.rsp_eventRegister rsp = Message.rsp_eventRegister.newBuilder().setResult(true).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.eventRegister exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_eventDeregister_VALUE:
{
if (service != Message.Servs.s_tx_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_eventDeregister req;
try {
req = Message.req_eventDeregister.parseFrom(data);
List<String> evtList = new ArrayList<>(req.getEventsList());
byte[] contractAddr;
if (req.getContractAddr() == null) {
contractAddr = null;
} else {
contractAddr = req.getContractAddr().toByteArray();
}
if (evtList.isEmpty()) {
LOG.error("ApiAion0.process.eventRegister : [{}]", "empty event list");
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
long lv = ByteUtil.byteArrayToLong(socketId);
FltrCt preFc = (FltrCt) installedFilters.get(lv);
boolean changed = false;
if (Optional.ofNullable(preFc).isPresent() && Arrays.equals(preFc.getContractAddr(), contractAddr)) {
evtList.forEach(ev -> preFc.getTopics().remove(ev));
installedFilters.put(lv, preFc);
changed = true;
}
Message.rsp_eventRegister rsp = Message.rsp_eventRegister.newBuilder().setResult(changed).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.eventDeregister exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockDetailsByNumber_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockDetailsByNumber req;
try {
req = Message.req_getBlockDetailsByNumber.parseFrom(data);
long latestBlkNum = this.getBestBlock().getNumber();
List<Long> blkNum = req.getBlkNumbersList().parallelStream().filter(n -> n <= latestBlkNum).collect(Collectors.toSet()).parallelStream().sorted().collect(Collectors.toList());
if (blkNum.size() > 1000) {
blkNum = blkNum.subList(0, 1000);
}
List<Block> blks = getBlocksForBlkNumList(blkNum);
if (blks == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
} else {
List<Message.t_BlockDetail> bds = getRsp_getBlockDetails(blks);
Message.rsp_getBlockDetailsByNumber rsp = Message.rsp_getBlockDetailsByNumber.newBuilder().addAllBlkDetails(bds).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockDetailsByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockSqlByRange_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockSqlByRange req;
try {
if (LOG.isDebugEnabled()) {
LOG.debug("BlockSqlByRange: start");
}
req = Message.req_getBlockSqlByRange.parseFrom(data);
long latestBlkNum = this.getBestBlock().getNumber();
Long _blkStart = req.getBlkNumberStart();
Long _blkEnd = req.getBlkNumberEnd();
// no null check here
long blkStart;
long blkEnd;
if (_blkStart < 0) {
blkStart = 0;
} else {
blkStart = _blkStart;
}
if (_blkEnd > latestBlkNum) {
blkEnd = latestBlkNum;
} else {
blkEnd = _blkEnd;
}
if (blkEnd < blkStart) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
// truncate the thing
if (blkEnd - blkStart > 1000) {
blkStart = blkEnd - 1000 + 1;
if (blkStart < 0) {
blkStart = 0;
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("BlockSqlByRange: range " + blkStart + "-" + blkEnd);
}
Long lastBlockTimestamp = null;
long listLength = blkEnd - blkStart + 1;
List<Message.t_BlockSql> bds = new ArrayList<>();
for (int i = 0; i < listLength; i++) {
long blkNum = blkStart + i;
Block b = getBlock(blkNum);
long blocktime;
if (blkNum != 0 && lastBlockTimestamp == null) {
lastBlockTimestamp = getBlock(blkNum - 1).getTimestamp();
}
if (blkNum == 0) {
blocktime = 0;
} else {
blocktime = b.getTimestamp() - lastBlockTimestamp;
}
lastBlockTimestamp = b.getTimestamp();
String blockSql = generateBlockSqlStatement(b, b.getTotalDifficulty(), blocktime);
List<String> transactionSql = new ArrayList<>();
AionBlockSummary bs = null;
if (explorerBlockCache != null) {
// remove from cache since after consumed, we're probably not gonna
// revisit it
bs = explorerBlockCache.remove(b.getHashWrapper());
}
if (bs != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("BlockSqlByRange: cache HIT for #: " + b.getNumber());
}
Map<ByteArrayWrapper, AionTxReceipt> receipts = new HashMap<>();
for (AionTxReceipt r : bs.getReceipts()) {
receipts.put(ByteArrayWrapper.wrap(r.getTransaction().getTransactionHash()), r);
}
List<AionTransaction> txns = b.getTransactionsList();
for (int j = 0; j < txns.size(); j++) {
AionTransaction tx = txns.get(j);
AionTxReceipt r = receipts.get(ByteArrayWrapper.wrap(tx.getTransactionHash()));
if (r == null) {
if (LOG.isDebugEnabled()) {
LOG.debug("BlockSqlByRange: transaction not in Block Summary: " + b.getNumber() + "." + j);
}
AionTxInfo ti = ((AionBlockchainImpl) this.ac.getAionHub().getBlockchain()).getTransactionInfoLite(tx.getTransactionHash(), b.getHash());
r = ti.getReceipt();
}
if (r == null) {
LOG.error("BlockSqlByRange: missing DB transaction: " + ByteUtil.toHexString(tx.getTransactionHash()));
} else {
transactionSql.add(generateTransactionSqlStatement(b, tx, r.getLogInfoList(), j, r.getEnergyUsed()));
}
}
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("BlockSqlByRange: cache MISS for #: " + b.getNumber());
}
List<AionTransaction> txs = b.getTransactionsList();
transactionSql = txs.parallelStream().filter(Objects::nonNull).map((AionTransaction tx) -> {
AionTxInfo ti = ((AionBlockchainImpl) this.ac.getAionHub().getBlockchain()).getTransactionInfoLite(tx.getTransactionHash(), b.getHash());
if (ti == null) {
LOG.error("BlockSqlByRange: missing DB transaction: " + ByteUtil.toHexString(tx.getTransactionHash()));
return null;
} else {
return generateTransactionSqlStatement(b, tx, ti.getReceipt().getLogInfoList(), ti.getIndex(), ti.getReceipt().getEnergyUsed());
}
}).filter(Objects::nonNull).collect(Collectors.toList());
}
Message.t_BlockSql sqlObj = Message.t_BlockSql.newBuilder().setBlockNumber(b.getNumber()).setBlockHash(ByteUtil.toHexString(b.getHash())).setParentHash(ByteUtil.toHexString(b.getParentHash())).setBlock(blockSql).addAllTx(transactionSql).build();
bds.add(sqlObj);
}
Message.rsp_getBlockSqlByRange rsp = Message.rsp_getBlockSqlByRange.newBuilder().addAllBlkSql(bds).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockDetailsByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockDetailsByRange_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockDetailsByRange req;
try {
if (LOG.isDebugEnabled()) {
LOG.debug("getBlockDetailsByRange: start");
}
req = Message.req_getBlockDetailsByRange.parseFrom(data);
long latestBlkNum = this.getBestBlock().getNumber();
Long _blkStart = req.getBlkNumberStart();
Long _blkEnd = req.getBlkNumberEnd();
// no null check here
long blkStart;
long blkEnd;
if (_blkStart < 0) {
blkStart = 0;
} else {
blkStart = _blkStart;
}
// blocks requested in the future. return empty result
if (blkStart > latestBlkNum) {
Message.rsp_getBlockDetailsByRange rsp = Message.rsp_getBlockDetailsByRange.newBuilder().addAllBlkDetails(new ArrayList<>()).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
if (_blkEnd > latestBlkNum) {
blkEnd = latestBlkNum;
} else {
blkEnd = _blkEnd;
}
if (blkEnd < blkStart) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
// truncate at the beginning of range
if (blkEnd - blkStart > 1000) {
blkStart = blkEnd - 1000 + 1;
if (blkStart < 0) {
blkStart = 0;
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("getBlockDetailsByRange: range " + blkStart + "-" + blkEnd);
}
Long lastBlockTimestamp = null;
long listLength = blkEnd - blkStart + 1;
List<Message.t_BlockDetail> bds = new ArrayList<>();
for (int i = 0; i < listLength; i++) {
long blkNum = blkStart + i;
Block b = getBlockWithInfo(blkNum);
if (b == null) {
throw new NullPointerException("Can retrieve the block#" + blkNum + "in the database!");
}
long blocktime = 0;
if (b.getNumber() > 0 && lastBlockTimestamp == null) {
lastBlockTimestamp = getBlockByHash(b.getParentHash()).getTimestamp();
}
if (lastBlockTimestamp != null) {
blocktime = b.getTimestamp() - lastBlockTimestamp;
}
lastBlockTimestamp = b.getTimestamp();
Message.t_BlockDetail.Builder blockDetails = getBlockDetailsObj(b, blocktime);
List<Message.t_TxDetail> txDetails = new ArrayList<>();
AionBlockSummary bs = null;
if (explorerBlockCache != null) {
// remove from cache since after consumed, we're probably not gonna
// revisit it
bs = explorerBlockCache.remove(b.getHashWrapper());
}
if (bs != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("getBlockDetailsByRange: cache HIT for #: " + b.getNumber());
}
Map<ByteArrayWrapper, AionTxReceipt> receipts = new HashMap<>();
for (AionTxReceipt r : bs.getReceipts()) {
receipts.put(ByteArrayWrapper.wrap(r.getTransaction().getTransactionHash()), r);
}
List<AionTransaction> txns = b.getTransactionsList();
for (int j = 0; j < txns.size(); j++) {
AionTransaction tx = txns.get(j);
AionTxReceipt r = receipts.get(ByteArrayWrapper.wrap(tx.getTransactionHash()));
if (r == null) {
if (LOG.isDebugEnabled()) {
LOG.debug("getBlockDetailsByRange: transaction not in Block Summary: " + b.getNumber() + "." + j);
}
AionTxInfo ti = ((AionBlockchainImpl) this.ac.getAionHub().getBlockchain()).getTransactionInfoLite(tx.getTransactionHash(), b.getHash());
r = ti.getReceipt();
}
if (r == null) {
LOG.error("getBlockDetailsByRange: missing DB transaction: " + ByteUtil.toHexString(tx.getTransactionHash()));
} else {
txDetails.add(getTxDetailsObj(tx, r.getLogInfoList(), j, r.getEnergyUsed(), r.getError()));
}
}
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("getBlockDetailsByRange: cache MISS for #: " + b.getNumber());
}
List<AionTransaction> txs = b.getTransactionsList();
txDetails = txs.parallelStream().filter(Objects::nonNull).map((AionTransaction tx) -> {
AionTxInfo ti = ((AionBlockchainImpl) this.ac.getAionHub().getBlockchain()).getTransactionInfoLite(tx.getTransactionHash(), b.getHash());
if (ti == null) {
LOG.error("getBlockDetailsByRange: missing DB transaction: " + ByteUtil.toHexString(tx.getTransactionHash()));
return null;
} else {
return getTxDetailsObj(tx, ti.getReceipt().getLogInfoList(), ti.getIndex(), ti.getReceipt().getEnergyUsed(), ti.getReceipt().getError());
}
}).filter(Objects::nonNull).collect(Collectors.toList());
}
bds.add(blockDetails.addAllTx(txDetails).build());
}
Message.rsp_getBlockDetailsByRange rsp = Message.rsp_getBlockDetailsByRange.newBuilder().addAllBlkDetails(bds).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockDetailsByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlockDetailsByLatest_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlockDetailsByLatest req;
try {
req = Message.req_getBlockDetailsByLatest.parseFrom(data);
// clip the requested count up to 1000
Long count = req.getCount();
if (count > 1000) {
count = 1000L;
}
// clip start block to 0 at the bottom
Long endBlock = this.getBestBlock().getNumber();
Long startBlock = (endBlock - count + 1) >= 0 ? (endBlock - count + 1) : 0;
List<Long> blkNum = LongStream.rangeClosed(startBlock, endBlock).boxed().collect(Collectors.toList());
List<Block> blks = getBlocksForBlkNumList(blkNum);
if (blks == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
} else {
List<Message.t_BlockDetail> bds = getRsp_getBlockDetails(blks);
Message.rsp_getBlockDetailsByLatest rsp = Message.rsp_getBlockDetailsByLatest.newBuilder().addAllBlkDetails(bds).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockDetailsByLatest exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getBlocksByLatest_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getBlocksByLatest req;
try {
req = Message.req_getBlocksByLatest.parseFrom(data);
// clip the requested count up to 1000
Long count = req.getCount();
if (count > 1000) {
count = 1000L;
}
// clip start block to 0 at the bottom
Long endBlock = this.getBestBlock().getNumber();
Long startBlock = (endBlock - count + 1) >= 0 ? (endBlock - count + 1) : 0;
List<Long> blkNum = LongStream.rangeClosed(startBlock, endBlock).boxed().collect(Collectors.toList());
List<Block> blks = getBlocksForBlkNumList(blkNum);
if (blks == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
} else {
List<Message.t_Block> bs = getRsp_getBlocks(blks);
Message.rsp_getBlocksByLatest rsp = Message.rsp_getBlocksByLatest.newBuilder().addAllBlks(bs).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
}
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlocksByLatest exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
case Message.Funcs.f_getAccountDetailsByAddressList_VALUE:
{
if (service != Message.Servs.s_admin_VALUE) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_service_call_VALUE);
}
byte[] data = parseMsgReq(request, msgHash);
Message.req_getAccountDetailsByAddressList req;
try {
req = Message.req_getAccountDetailsByAddressList.parseFrom(data);
List<ByteString> num = req.getAddressesList();
if (num.size() > 1000) {
num = num.subList(0, 1000);
}
List<Message.t_AccountDetail> accounts = num.parallelStream().map(a -> {
BigInteger b = this.getBalance(new AionAddress(a.toByteArray()));
Message.t_AccountDetail.Builder builder = Message.t_AccountDetail.newBuilder();
if (b != null) {
builder.setBalance(ByteString.copyFrom(b.toByteArray()));
}
builder.setAddress(a);
return builder.build();
}).collect(Collectors.toList());
if (accounts == null) {
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_arguments_VALUE);
}
Message.rsp_getAccountDetailsByAddressList rsp = Message.rsp_getAccountDetailsByAddressList.newBuilder().addAllAccounts(accounts).build();
byte[] retHeader = ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_success_VALUE);
return ApiUtil.combineRetMsg(retHeader, rsp.toByteArray());
} catch (Exception e) {
LOG.error("ApiAion0.process.getBlockDetailsByNumber exception: [{}]", e);
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_exception_VALUE);
}
}
// case Message.Funcs.f_getWork_VALUE:
default:
return ApiUtil.toReturnHeader(getApiVersion(), Retcode.r_fail_function_call_VALUE);
}
}
Also used :
Funcs(org.aion.api.server.pb.Message.Funcs)
Arrays(java.util.Arrays)
ApiTxResponse(org.aion.api.server.ApiTxResponse)
ArgTxCall(org.aion.api.server.types.ArgTxCall)
Seal(org.aion.zero.impl.types.BlockHeader.Seal)
Version(org.aion.zero.impl.Version)
NodeWrapper(org.aion.zero.impl.sync.NodeWrapper)
LRUMap(org.apache.commons.collections4.map.LRUMap)
AionTxReceipt(org.aion.base.AionTxReceipt)
ByteBuffer(java.nio.ByteBuffer)
FltrCt(org.aion.api.server.types.FltrCt)
AddressUtils(org.aion.util.types.AddressUtils)
Map(java.util.Map)
BigInteger(java.math.BigInteger)
MiningBlock(org.aion.zero.impl.types.MiningBlock)
Block(org.aion.zero.impl.types.Block)
IApiAion(org.aion.api.server.IApiAion)
AionAddress(org.aion.types.AionAddress)
InvalidProtocolBufferException(com.google.protobuf.InvalidProtocolBufferException)
Fltr(org.aion.api.server.types.Fltr)
Keystore(org.aion.zero.impl.keystore.Keystore)
Set(java.util.Set)
BlockingQueue(java.util.concurrent.BlockingQueue)
ByteUtil(org.aion.util.bytes.ByteUtil)
LinkedBlockingQueue(java.util.concurrent.LinkedBlockingQueue)
Collectors(java.util.stream.Collectors)
EvtTx(org.aion.api.server.types.EvtTx)
EventCallback(org.aion.evtmgr.impl.callback.EventCallback)
TxRecpt(org.aion.api.server.types.TxRecpt)
ByteString(com.google.protobuf.ByteString)
Objects(java.util.Objects)
TxUtil(org.aion.base.TxUtil)
EquihashMiner(org.aion.equihash.EquihashMiner)
List(java.util.List)
StringUtils(org.aion.util.string.StringUtils)
Entry(java.util.Map.Entry)
PendingTransactionState(org.aion.zero.impl.pendingState.PendingTransactionState)
Optional(java.util.Optional)
AionBlockSummary(org.aion.zero.impl.types.AionBlockSummary)
SyncInfo(org.aion.api.server.types.SyncInfo)
EvtContract(org.aion.api.server.types.EvtContract)
CfgAion(org.aion.zero.impl.config.CfgAion)
AionHub(org.aion.zero.impl.blockchain.AionHub)
Hash256(org.aion.util.types.Hash256)
Servs(org.aion.api.server.pb.Message.Servs)
IEvent(org.aion.evtmgr.IEvent)
HashMap(java.util.HashMap)
EventBlock(org.aion.evtmgr.impl.evt.EventBlock)
ArrayList(java.util.ArrayList)
HashSet(java.util.HashSet)
ByteArrayWrapper(org.aion.util.types.ByteArrayWrapper)
AccountManager(org.aion.api.server.account.AccountManager)
IAionChain(org.aion.zero.impl.blockchain.IAionChain)
Retcode(org.aion.api.server.pb.Message.Retcode)
StakingBlock(org.aion.zero.impl.types.StakingBlock)
ApiAion(org.aion.api.server.ApiAion)
IHandler(org.aion.evtmgr.IHandler)
LongStream(java.util.stream.LongStream)
ApiUtil(org.aion.api.server.ApiUtil)
Hex(org.aion.util.conversions.Hex)
Log(org.aion.types.Log)
TxRecptLg(org.aion.api.server.types.TxRecptLg)
EventExecuteService(org.aion.evtmgr.impl.es.EventExecuteService)
CompiledContr(org.aion.api.server.types.CompiledContr)
AionBlockchainImpl(org.aion.zero.impl.blockchain.AionBlockchainImpl)
AbstractMap(java.util.AbstractMap)
EMPTY_BYTE_ARRAY(org.aion.util.bytes.ByteUtil.EMPTY_BYTE_ARRAY)
AionTxInfo(org.aion.zero.impl.types.AionTxInfo)
AionTransaction(org.aion.base.AionTransaction)
Collections(java.util.Collections)
TxPendingStatus(org.aion.api.server.types.TxPendingStatus)
JSONArray(org.json.JSONArray)
AionTxInfo(org.aion.zero.impl.types.AionTxInfo)
ByteString(com.google.protobuf.ByteString)
ArrayList(java.util.ArrayList)
ByteString(com.google.protobuf.ByteString)
CompiledContr(org.aion.api.server.types.CompiledContr)
SyncInfo(org.aion.api.server.types.SyncInfo)
TxRecptLg(org.aion.api.server.types.TxRecptLg)
AionTxReceipt(org.aion.base.AionTxReceipt)
LRUMap(org.apache.commons.collections4.map.LRUMap)
Map(java.util.Map)
HashMap(java.util.HashMap)
AbstractMap(java.util.AbstractMap)
Set(java.util.Set)
HashSet(java.util.HashSet)
Entry(java.util.Map.Entry)
TxRecpt(org.aion.api.server.types.TxRecpt)
NodeWrapper(org.aion.zero.impl.sync.NodeWrapper)
ArgTxCall(org.aion.api.server.types.ArgTxCall)
AionBlockSummary(org.aion.zero.impl.types.AionBlockSummary)
List(java.util.List)
ArrayList(java.util.ArrayList)
AionAddress(org.aion.types.AionAddress)
Optional(java.util.Optional)
BigInteger(java.math.BigInteger)
MiningBlock(org.aion.zero.impl.types.MiningBlock)
Block(org.aion.zero.impl.types.Block)
EventBlock(org.aion.evtmgr.impl.evt.EventBlock)
StakingBlock(org.aion.zero.impl.types.StakingBlock)
InvalidProtocolBufferException(com.google.protobuf.InvalidProtocolBufferException)
JSONArray(org.json.JSONArray)
AionTransaction(org.aion.base.AionTransaction)
InvalidProtocolBufferException(com.google.protobuf.InvalidProtocolBufferException)
FltrCt(org.aion.api.server.types.FltrCt)
ApiTxResponse(org.aion.api.server.ApiTxResponse)
AionBlockchainImpl(org.aion.zero.impl.blockchain.AionBlockchainImpl)
Example 3 with NodeWrapper
use of org.aion.zero.impl.sync.NodeWrapper in project aion by aionnetwork.
the class ApiWeb3Aion method priv_shortStats.
/**
* Very short blurb generated about our most important stats, intended for quick digestion and
* monitoring tool usage
*/
// TODO
public RpcMsg priv_shortStats() {
Block block = this.ac.getBlockchain().getBestBlock();
Map<Integer, NodeWrapper> peer = this.ac.getAionHub().getActiveNodes();
// this could be optimized (cached)
NodeWrapper maxPeer = null;
for (NodeWrapper p : peer.values()) {
if (maxPeer == null) {
maxPeer = p;
continue;
}
if (p.getTotalDifficulty().compareTo(maxPeer.getTotalDifficulty()) > 0) {
maxPeer = p;
}
}
// basic local configuration
CfgAion config = CfgAion.inst();
JSONObject obj = new JSONObject();
obj.put("id", config.getId());
obj.put("genesisHash", ByteUtil.toHexString(config.getGenesis().getHash()));
obj.put("version", Version.KERNEL_VERSION);
obj.put("bootBlock", this.ac.getAionHub().getStartingBlock().getNumber());
long time = System.currentTimeMillis();
obj.put("timestamp", time);
obj.put("timestampUTC", Instant.ofEpochMilli(time).atOffset(ZoneOffset.UTC).toString());
// base.blockchain
JSONObject blockchain = new JSONObject();
blockchain.put("bestBlockhash", ByteUtil.toHexString(block.getHash()));
blockchain.put("bestNumber", block.getNumber());
blockchain.put("totalDifficulty", this.ac.getBlockchain().getTotalDifficultyForHash(block.getHash()));
// end
obj.put("local", blockchain);
// base.network
JSONObject network = new JSONObject();
// remote
if (maxPeer != null) {
// base.network.best
JSONObject remote = new JSONObject();
remote.put("id", new String(maxPeer.getId()));
remote.put("totalDifficulty", maxPeer.getTotalDifficulty());
remote.put("bestNumber", maxPeer.getBestBlockNumber());
remote.put("version", maxPeer.getBinaryVersion());
remote.put("timestamp", maxPeer.getTimestamp());
remote.put("timestampUTC", Instant.ofEpochMilli(maxPeer.getTimestamp()).atOffset(ZoneOffset.UTC).toString());
// end
network.put("best", remote);
}
// end
network.put("peerCount", peer.size());
obj.put("network", network);
return new RpcMsg(obj);
}
Also used :
BigInteger(java.math.BigInteger)
CfgAion(org.aion.zero.impl.config.CfgAion)
JSONObject(org.json.JSONObject)
MiningBlock(org.aion.zero.impl.types.MiningBlock)
Block(org.aion.zero.impl.types.Block)
StakingBlock(org.aion.zero.impl.types.StakingBlock)
NodeWrapper(org.aion.zero.impl.sync.NodeWrapper)
Hex.toHexString(org.aion.util.conversions.Hex.toHexString)
Aggregations
BigInteger (java.math.BigInteger)3
NodeWrapper (org.aion.zero.impl.sync.NodeWrapper)3
JSONArray (org.json.JSONArray)2
ByteString (com.google.protobuf.ByteString)1
InvalidProtocolBufferException (com.google.protobuf.InvalidProtocolBufferException)1
ByteBuffer (java.nio.ByteBuffer)1
AbstractMap (java.util.AbstractMap)1
ArrayList (java.util.ArrayList)1
Arrays (java.util.Arrays)1
Collections (java.util.Collections)1
HashMap (java.util.HashMap)1
HashSet (java.util.HashSet)1
List (java.util.List)1
Map (java.util.Map)1
Entry (java.util.Map.Entry)1
Objects (java.util.Objects)1
Optional (java.util.Optional)1
Set (java.util.Set)1
BlockingQueue (java.util.concurrent.BlockingQueue)1
LinkedBlockingQueue (java.util.concurrent.LinkedBlockingQueue)1
