/*

* Copyright (c) [2016] [ <ether.camp> ]

* This file is part of the ethereumJ library.

*

* The ethereumJ library is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* The ethereumJ library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with the ethereumJ library. If not, see <http://www.gnu.org/licenses/>.

*/

package org.tron.core;

import static org.tron.common.utils.Commons.getAssetIssueStoreFinal;

import static org.tron.common.utils.Commons.getExchangeStoreFinal;

import static org.tron.common.utils.WalletUtil.isConstant;

import static org.tron.core.capsule.utils.TransactionUtil.buildInternalTransaction;

import static org.tron.core.config.Parameter.ChainConstant.BLOCK_PRODUCED_INTERVAL;

import static org.tron.core.config.Parameter.ChainConstant.TRX_PRECISION;

import static org.tron.core.config.Parameter.DatabaseConstants.EXCHANGE_COUNT_LIMIT_MAX;

import static org.tron.core.config.Parameter.DatabaseConstants.MARKET_COUNT_LIMIT_MAX;

import static org.tron.core.config.Parameter.DatabaseConstants.PROPOSAL_COUNT_LIMIT_MAX;

import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.parseEnergyFee;

import static org.tron.core.services.jsonrpc.TronJsonRpcImpl.EARLIEST_STR;

import static org.tron.core.vm.utils.FreezeV2Util.getV2EnergyUsage;

import static org.tron.core.vm.utils.FreezeV2Util.getV2NetUsage;

import static org.tron.protos.contract.Common.ResourceCode;

import com.google.common.collect.ContiguousSet;

import com.google.common.collect.DiscreteDomain;

import com.google.common.collect.ImmutableList;

import com.google.common.collect.Lists;

import com.google.common.collect.Range;

import com.google.protobuf.ByteString;

import com.google.protobuf.InvalidProtocolBufferException;

import com.google.protobuf.ProtocolStringList;

import java.math.BigInteger;

import java.security.SignatureException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Objects;

import java.util.Optional;

import lombok.Getter;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.Pair;

import org.bouncycastle.util.encoders.DecoderException;

import org.bouncycastle.util.encoders.Hex;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.util.CollectionUtils;

import org.tron.api.GrpcAPI;

import org.tron.api.GrpcAPI.AccountNetMessage;

import org.tron.api.GrpcAPI.AccountResourceMessage;

import org.tron.api.GrpcAPI.Address;

import org.tron.api.GrpcAPI.AssetIssueList;

import org.tron.api.GrpcAPI.BlockList;

import org.tron.api.GrpcAPI.BytesMessage;

import org.tron.api.GrpcAPI.DecryptNotes;

import org.tron.api.GrpcAPI.DecryptNotes.NoteTx;

import org.tron.api.GrpcAPI.DecryptNotesTRC20;

import org.tron.api.GrpcAPI.DelegatedResourceList;

import org.tron.api.GrpcAPI.DiversifierMessage;

import org.tron.api.GrpcAPI.ExchangeList;

import org.tron.api.GrpcAPI.ExpandedSpendingKeyMessage;

import org.tron.api.GrpcAPI.IncomingViewingKeyMessage;

import org.tron.api.GrpcAPI.NfParameters;

import org.tron.api.GrpcAPI.NfTRC20Parameters;

import org.tron.api.GrpcAPI.Node;

import org.tron.api.GrpcAPI.NodeList;

import org.tron.api.GrpcAPI.NoteParameters;

import org.tron.api.GrpcAPI.NumberMessage;

import org.tron.api.GrpcAPI.PaymentAddressMessage;

import org.tron.api.GrpcAPI.PricesResponseMessage;

import org.tron.api.GrpcAPI.PrivateParameters;

import org.tron.api.GrpcAPI.PrivateParametersWithoutAsk;

import org.tron.api.GrpcAPI.PrivateShieldedTRC20Parameters;

import org.tron.api.GrpcAPI.PrivateShieldedTRC20ParametersWithoutAsk;

import org.tron.api.GrpcAPI.ProposalList;

import org.tron.api.GrpcAPI.ReceiveNote;

import org.tron.api.GrpcAPI.Return;

import org.tron.api.GrpcAPI.Return.response_code;

import org.tron.api.GrpcAPI.ShieldedAddressInfo;

import org.tron.api.GrpcAPI.ShieldedTRC20Parameters;

import org.tron.api.GrpcAPI.ShieldedTRC20TriggerContractParameters;

import org.tron.api.GrpcAPI.SpendAuthSigParameters;

import org.tron.api.GrpcAPI.SpendNote;

import org.tron.api.GrpcAPI.SpendResult;

import org.tron.api.GrpcAPI.TransactionApprovedList;

import org.tron.api.GrpcAPI.TransactionExtention;

import org.tron.api.GrpcAPI.TransactionExtention.Builder;

import org.tron.api.GrpcAPI.TransactionInfoList;

import org.tron.api.GrpcAPI.WitnessList;

import org.tron.common.crypto.Hash;

import org.tron.common.crypto.SignInterface;

import org.tron.common.crypto.SignUtils;

import org.tron.common.parameter.CommonParameter;

import org.tron.common.runtime.ProgramResult;

import org.tron.common.runtime.vm.LogInfo;

import org.tron.common.utils.ByteArray;

import org.tron.common.utils.ByteUtil;

import org.tron.common.utils.DecodeUtil;

import org.tron.common.utils.Sha256Hash;

import org.tron.common.utils.StringUtil;

import org.tron.common.utils.Utils;

import org.tron.common.utils.WalletUtil;

import org.tron.common.zksnark.IncrementalMerkleTreeContainer;

import org.tron.common.zksnark.IncrementalMerkleVoucherContainer;

import org.tron.common.zksnark.JLibrustzcash;

import org.tron.common.zksnark.LibrustzcashParam.ComputeNfParams;

import org.tron.common.zksnark.LibrustzcashParam.CrhIvkParams;

import org.tron.common.zksnark.LibrustzcashParam.IvkToPkdParams;

import org.tron.common.zksnark.LibrustzcashParam.SpendSigParams;

import org.tron.consensus.ConsensusDelegate;

import org.tron.core.actuator.Actuator;

import org.tron.core.actuator.ActuatorConstant;

import org.tron.core.actuator.ActuatorFactory;

import org.tron.core.actuator.UnfreezeBalanceV2Actuator;

import org.tron.core.actuator.VMActuator;

import org.tron.core.capsule.AbiCapsule;

import org.tron.core.capsule.AccountCapsule;

import org.tron.core.capsule.AssetIssueCapsule;

import org.tron.core.capsule.BlockBalanceTraceCapsule;

import org.tron.core.capsule.BlockCapsule;

import org.tron.core.capsule.BlockCapsule.BlockId;

import org.tron.core.capsule.BytesCapsule;

import org.tron.core.capsule.CodeCapsule;

import org.tron.core.capsule.ContractCapsule;

import org.tron.core.capsule.ContractStateCapsule;

import org.tron.core.capsule.DelegatedResourceAccountIndexCapsule;

import org.tron.core.capsule.DelegatedResourceCapsule;

import org.tron.core.capsule.ExchangeCapsule;

import org.tron.core.capsule.IncrementalMerkleTreeCapsule;

import org.tron.core.capsule.IncrementalMerkleVoucherCapsule;

import org.tron.core.capsule.MarketAccountOrderCapsule;

import org.tron.core.capsule.MarketOrderCapsule;

import org.tron.core.capsule.MarketOrderIdListCapsule;

import org.tron.core.capsule.PedersenHashCapsule;

import org.tron.core.capsule.ProposalCapsule;

import org.tron.core.capsule.TransactionCapsule;

import org.tron.core.capsule.TransactionInfoCapsule;

import org.tron.core.capsule.TransactionResultCapsule;

import org.tron.core.capsule.TransactionRetCapsule;

import org.tron.core.capsule.WitnessCapsule;

import org.tron.core.capsule.utils.MarketUtils;

import org.tron.core.config.args.Args;

import org.tron.core.db.BandwidthProcessor;

import org.tron.core.db.BlockIndexStore;

import org.tron.core.db.EnergyProcessor;

import org.tron.core.db.Manager;

import org.tron.core.db.TransactionContext;

import org.tron.core.db2.core.Chainbase;

import org.tron.core.exception.AccountResourceInsufficientException;

import org.tron.core.exception.BadItemException;

import org.tron.core.exception.ContractExeException;

import org.tron.core.exception.ContractValidateException;

import org.tron.core.exception.DupTransactionException;

import org.tron.core.exception.HeaderNotFound;

import org.tron.core.exception.ItemNotFoundException;

import org.tron.core.exception.JsonRpcInvalidParamsException;

import org.tron.core.exception.NonUniqueObjectException;

import org.tron.core.exception.PermissionException;

import org.tron.core.exception.SignatureFormatException;

import org.tron.core.exception.StoreException;

import org.tron.core.exception.TaposException;

import org.tron.core.exception.TooBigTransactionException;

import org.tron.core.exception.TransactionExpirationException;

import org.tron.core.exception.VMIllegalException;

import org.tron.core.exception.ValidateSignatureException;

import org.tron.core.exception.ZksnarkException;

import org.tron.core.net.TronNetDelegate;

import org.tron.core.net.TronNetService;

import org.tron.core.net.message.adv.TransactionMessage;

import org.tron.core.store.AccountIdIndexStore;

import org.tron.core.store.AccountStore;

import org.tron.core.store.AccountTraceStore;

import org.tron.core.store.BalanceTraceStore;

import org.tron.core.store.ContractStore;

import org.tron.core.store.DynamicPropertiesStore;

import org.tron.core.store.MarketOrderStore;

import org.tron.core.store.MarketPairPriceToOrderStore;

import org.tron.core.store.MarketPairToPriceStore;

import org.tron.core.store.StoreFactory;

import org.tron.core.utils.TransactionUtil;

import org.tron.core.vm.program.Program;

import org.tron.core.zen.ShieldedTRC20ParametersBuilder;

import org.tron.core.zen.ShieldedTRC20ParametersBuilder.ShieldedTRC20ParametersType;

import org.tron.core.zen.ZenTransactionBuilder;

import org.tron.core.zen.address.DiversifierT;

import org.tron.core.zen.address.ExpandedSpendingKey;

import org.tron.core.zen.address.IncomingViewingKey;

import org.tron.core.zen.address.KeyIo;

import org.tron.core.zen.address.PaymentAddress;

import org.tron.core.zen.address.SpendingKey;

import org.tron.core.zen.note.Note;

import org.tron.core.zen.note.NoteEncryption;

import org.tron.core.zen.note.NoteEncryption.Encryption;

import org.tron.core.zen.note.OutgoingPlaintext;

import org.tron.protos.Protocol;

import org.tron.protos.Protocol.Account;

import org.tron.protos.Protocol.Account.FreezeV2;

import org.tron.protos.Protocol.Account.UnFreezeV2;

import org.tron.protos.Protocol.Block;

import org.tron.protos.Protocol.DelegatedResourceAccountIndex;

import org.tron.protos.Protocol.Exchange;

import org.tron.protos.Protocol.MarketOrder;

import org.tron.protos.Protocol.MarketOrderList;

import org.tron.protos.Protocol.MarketOrderPairList;

import org.tron.protos.Protocol.MarketPrice;

import org.tron.protos.Protocol.MarketPriceList;

import org.tron.protos.Protocol.Proposal;

import org.tron.protos.Protocol.Transaction;

import org.tron.protos.Protocol.Transaction.Contract;

import org.tron.protos.Protocol.Transaction.Contract.ContractType;

import org.tron.protos.Protocol.Transaction.Result.code;

import org.tron.protos.Protocol.TransactionInfo;

import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract;

import org.tron.protos.contract.BalanceContract;

import org.tron.protos.contract.BalanceContract.BlockBalanceTrace;

import org.tron.protos.contract.BalanceContract.TransferContract;

import org.tron.protos.contract.Common;

import org.tron.protos.contract.ShieldContract.IncrementalMerkleTree;

import org.tron.protos.contract.ShieldContract.IncrementalMerkleVoucherInfo;

import org.tron.protos.contract.ShieldContract.OutputPoint;

import org.tron.protos.contract.ShieldContract.OutputPointInfo;

import org.tron.protos.contract.ShieldContract.PedersenHash;

import org.tron.protos.contract.ShieldContract.ReceiveDescription;

import org.tron.protos.contract.ShieldContract.ShieldedTransferContract;

import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract;

import org.tron.protos.contract.SmartContractOuterClass.SmartContract;

import org.tron.protos.contract.SmartContractOuterClass.SmartContractDataWrapper;

import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract;

@Slf4j

@Component

public class Wallet {

private static final String SHIELDED_ID_NOT_ALLOWED = "ShieldedTransactionApi is not allowed";

private static final String PAYMENT_ADDRESS_FORMAT_WRONG = "paymentAddress format is wrong";

private static final String SHIELDED_TRANSACTION_SCAN_RANGE =

"request requires start_block_index >= 0 && end_block_index > "

+ "start_block_index && end_block_index - start_block_index <= 1000";

private static String addressPreFixString = Constant.ADD_PRE_FIX_STRING_MAINNET;//default testnet

private static final byte[] SHIELDED_TRC20_LOG_TOPICS_MINT = Hash.sha3(ByteArray.fromString(

"MintNewLeaf(uint256,bytes32,bytes32,bytes32,bytes32[21])"));

private static final byte[] SHIELDED_TRC20_LOG_TOPICS_TRANSFER = Hash.sha3(ByteArray.fromString(

"TransferNewLeaf(uint256,bytes32,bytes32,bytes32,bytes32[21])"));

private static final byte[] SHIELDED_TRC20_LOG_TOPICS_BURN_LEAF = Hash.sha3(ByteArray.fromString(

"BurnNewLeaf(uint256,bytes32,bytes32,bytes32,bytes32[21])"));

private static final byte[] SHIELDED_TRC20_LOG_TOPICS_BURN_TOKEN = Hash.sha3(ByteArray

.fromString("TokenBurn(address,uint256,bytes32[3])"));

private static final String BROADCAST_TRANS_FAILED = "Broadcast transaction {} failed, {}.";

@Getter

private final SignInterface cryptoEngine;

@Autowired

private TronNetService tronNetService;

@Autowired

private TronNetDelegate tronNetDelegate;

@Autowired

private Manager dbManager;

@Autowired

private ConsensusDelegate consensusDelegate;

@Autowired

private ChainBaseManager chainBaseManager;

private int minEffectiveConnection = CommonParameter.getInstance().getMinEffectiveConnection();

private boolean trxCacheEnable = CommonParameter.getInstance().isTrxCacheEnable();

public static final String CONTRACT_VALIDATE_EXCEPTION = "ContractValidateException: {}";

public static final String CONTRACT_VALIDATE_ERROR = "Contract validate error : ";

/**

* Creates a new Wallet with a random ECKey.

*/

public Wallet() {

this.cryptoEngine = SignUtils.getGeneratedRandomSign(Utils.getRandom(),

CommonParameter.getInstance().isECKeyCryptoEngine());

}

/**

* Creates a Wallet with an existing ECKey.

*/

public Wallet(final SignInterface cryptoEngine) {

this.cryptoEngine = cryptoEngine;

logger.info("wallet address: {}", ByteArray.toHexString(this.cryptoEngine.getAddress()));

}

public static String getAddressPreFixString() {

return DecodeUtil.addressPreFixString;

}

public static void setAddressPreFixString(String addressPreFixString) {

DecodeUtil.addressPreFixString = addressPreFixString;

}

public static byte getAddressPreFixByte() {

return DecodeUtil.addressPreFixByte;

}

public static void setAddressPreFixByte(byte addressPreFixByte) {

DecodeUtil.addressPreFixByte = addressPreFixByte;

}

public byte[] getAddress() {

return cryptoEngine.getAddress();

}

public Account getAccount(Account account) {

AccountStore accountStore = chainBaseManager.getAccountStore();

AccountCapsule accountCapsule = accountStore.get(account.getAddress().toByteArray());

if (accountCapsule == null) {

return null;

}

accountCapsule.importAllAsset();

BandwidthProcessor processor = new BandwidthProcessor(chainBaseManager);

processor.updateUsage(accountCapsule);

EnergyProcessor energyProcessor = new EnergyProcessor(

chainBaseManager.getDynamicPropertiesStore(),

chainBaseManager.getAccountStore());

energyProcessor.updateUsage(accountCapsule);

long genesisTimeStamp = chainBaseManager.getGenesisBlock().getTimeStamp();

accountCapsule.setLatestConsumeTime(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeTime());

accountCapsule.setLatestConsumeFreeTime(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeFreeTime());

accountCapsule.setLatestConsumeTimeForEnergy(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeTimeForEnergy());

sortFrozenV2List(accountCapsule);

return accountCapsule.getInstance();

}

private void sortFrozenV2List(AccountCapsule accountCapsule) {

List<FreezeV2> oldFreezeV2List = accountCapsule.getFrozenV2List();

accountCapsule.clearFrozenV2();

for (ResourceCode code : ResourceCode.values()) {

if (ResourceCode.UNRECOGNIZED != code) {

accountCapsule.addFrozenV2List(FreezeV2.newBuilder().setType(code).setAmount(0).build());

}

}

List<FreezeV2> newFreezeV2List = accountCapsule.getFrozenV2List();

for (int i = 0; i < newFreezeV2List.size(); i++) {

FreezeV2 freezeV2 = newFreezeV2List.get(i);

ResourceCode code = freezeV2.getType();

Optional<FreezeV2> optional = oldFreezeV2List

.stream().filter(o -> o.getType() == code).findFirst();

if (optional.isPresent()) {

accountCapsule.updateFrozenV2List(i, optional.get());

}

}

}

public Account getAccountById(Account account) {

AccountStore accountStore = chainBaseManager.getAccountStore();

AccountIdIndexStore accountIdIndexStore = chainBaseManager.getAccountIdIndexStore();

byte[] address = accountIdIndexStore.get(account.getAccountId());

if (address == null) {

return null;

}

AccountCapsule accountCapsule = accountStore.get(address);

if (accountCapsule == null) {

return null;

}

accountCapsule.importAllAsset();

BandwidthProcessor processor = new BandwidthProcessor(chainBaseManager);

processor.updateUsage(accountCapsule);

EnergyProcessor energyProcessor = new EnergyProcessor(

chainBaseManager.getDynamicPropertiesStore(),

chainBaseManager.getAccountStore());

energyProcessor.updateUsage(accountCapsule);

long genesisTimeStamp = chainBaseManager.getGenesisBlock().getTimeStamp();

accountCapsule.setLatestConsumeTime(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeTime());

accountCapsule.setLatestConsumeFreeTime(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeFreeTime());

accountCapsule.setLatestConsumeTimeForEnergy(genesisTimeStamp

+ BLOCK_PRODUCED_INTERVAL * accountCapsule.getLatestConsumeTimeForEnergy());

return accountCapsule.getInstance();

}

/**

* Create a transaction by contract.

*/

@Deprecated

public Transaction createTransaction(TransferContract contract) {

AccountStore accountStore = chainBaseManager.getAccountStore();

return new TransactionCapsule(contract, accountStore).getInstance();

}

private void setTransaction(TransactionCapsule trx) {

try {

BlockId blockId = chainBaseManager.getHeadBlockId();

if ("solid".equals(Args.getInstance().getTrxReferenceBlock())) {

blockId = chainBaseManager.getSolidBlockId();

}

trx.setReference(blockId.getNum(), blockId.getBytes());

long expiration = chainBaseManager.getHeadBlockTimeStamp() + Args.getInstance()

.getTrxExpirationTimeInMilliseconds();

trx.setExpiration(expiration);

trx.setTimestamp();

} catch (Exception e) {

logger.error("Create transaction capsule failed.", e);

}

}

private TransactionCapsule createTransactionCapsuleWithoutValidateWithTimeout(

com.google.protobuf.Message message,

ContractType contractType,

long timeout) {

TransactionCapsule trx = new TransactionCapsule(message, contractType);

try {

BlockId blockId = chainBaseManager.getHeadBlockId();

if ("solid".equals(Args.getInstance().getTrxReferenceBlock())) {

blockId = chainBaseManager.getSolidBlockId();

}

trx.setReference(blockId.getNum(), blockId.getBytes());

long expiration;

if (timeout > 0) {

expiration =

chainBaseManager.getHeadBlockTimeStamp() + timeout * 1000;

} else {

expiration =

chainBaseManager.getHeadBlockTimeStamp() + Args.getInstance()

.getTrxExpirationTimeInMilliseconds();

}

trx.setExpiration(expiration);

trx.setTimestamp();

} catch (Exception e) {

logger.error("Create transaction capsule failed.", e);

}

return trx;

}

public TransactionCapsule createTransactionCapsuleWithoutValidate(

com.google.protobuf.Message message,

ContractType contractType,

long timeout) {

return createTransactionCapsuleWithoutValidateWithTimeout(message, contractType, timeout);

}

public TransactionCapsule createTransactionCapsuleWithoutValidate(

com.google.protobuf.Message message,

ContractType contractType) {

return createTransactionCapsuleWithoutValidateWithTimeout(message, contractType, 0);

}

public TransactionCapsule createTransactionCapsule(com.google.protobuf.Message message,

ContractType contractType) throws ContractValidateException {

TransactionCapsule trx = new TransactionCapsule(message, contractType);

trx.setTransactionCreate(true);

if (contractType != ContractType.CreateSmartContract

&& contractType != ContractType.TriggerSmartContract) {

List<Actuator> actList = ActuatorFactory.createActuator(trx, chainBaseManager);

for (Actuator act : actList) {

act.validate();

}

}

trx.setTransactionCreate(false);

if (contractType == ContractType.CreateSmartContract) {

CreateSmartContract contract = ContractCapsule

.getSmartContractFromTransaction(trx.getInstance());

long percent = contract.getNewContract().getConsumeUserResourcePercent();

if (percent < 0 || percent > 100) {

throw new ContractValidateException("percent must be >= 0 and <= 100");

}

}

setTransaction(trx);

return trx;

}

/**

* Broadcast a transaction.

*/

public GrpcAPI.Return broadcastTransaction(Transaction signedTransaction) {

GrpcAPI.Return.Builder builder = GrpcAPI.Return.newBuilder();

TransactionCapsule trx = new TransactionCapsule(signedTransaction);

trx.setTime(System.currentTimeMillis());

Sha256Hash txID = trx.getTransactionId();

try {

TransactionMessage message = new TransactionMessage(signedTransaction.toByteArray());

if (minEffectiveConnection != 0) {

if (tronNetDelegate.getActivePeer().isEmpty()) {

logger.warn("Broadcast transaction {} has failed, no connection.", txID);

return builder.setResult(false).setCode(response_code.NO_CONNECTION)

.setMessage(ByteString.copyFromUtf8("No connection."))

.build();

}

int count = (int) tronNetDelegate.getActivePeer().stream()

.filter(p -> !p.isNeedSyncFromUs() && !p.isNeedSyncFromPeer())

.count();

if (count < minEffectiveConnection) {

String info = "Effective connection:" + count + " lt minEffectiveConnection:"

+ minEffectiveConnection;

logger.warn("Broadcast transaction {} has failed. {}.", txID, info);

return builder.setResult(false).setCode(response_code.NOT_ENOUGH_EFFECTIVE_CONNECTION)

.setMessage(ByteString.copyFromUtf8(info))

.build();

}

}

if (dbManager.isTooManyPending()) {

logger.warn("Broadcast transaction {} has failed, too many pending.", txID);

return builder.setResult(false).setCode(response_code.SERVER_BUSY)

.setMessage(ByteString.copyFromUtf8("Server busy.")).build();

}

if (trxCacheEnable) {

if (dbManager.getTransactionIdCache().getIfPresent(txID) != null) {

logger.warn("Broadcast transaction {} has failed, it already exists.", txID);

return builder.setResult(false).setCode(response_code.DUP_TRANSACTION_ERROR)

.setMessage(ByteString.copyFromUtf8("Transaction already exists.")).build();

} else {

dbManager.getTransactionIdCache().put(txID, true);

}

}

if (chainBaseManager.getDynamicPropertiesStore().supportVM()) {

trx.resetResult();

}

if (trx.getInstance().getRawData().getContractCount() == 0) {

throw new ContractValidateException(ActuatorConstant.CONTRACT_NOT_EXIST);

}

dbManager.pushTransaction(trx);

int num = tronNetService.fastBroadcastTransaction(message);

if (num == 0 && minEffectiveConnection != 0) {

return builder.setResult(false).setCode(response_code.NOT_ENOUGH_EFFECTIVE_CONNECTION)

.setMessage(ByteString.copyFromUtf8("P2P broadcast failed.")).build();

} else {

logger.info("Broadcast transaction {} to {} peers successfully.", txID, num);

return builder.setResult(true).setCode(response_code.SUCCESS).build();

}

} catch (ValidateSignatureException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.SIGERROR)

.setMessage(ByteString.copyFromUtf8("Validate signature error: " + e.getMessage()))

.build();

} catch (ContractValidateException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.CONTRACT_VALIDATE_ERROR)

.setMessage(ByteString.copyFromUtf8(CONTRACT_VALIDATE_ERROR + e.getMessage()))

.build();

} catch (ContractExeException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.CONTRACT_EXE_ERROR)

.setMessage(ByteString.copyFromUtf8("Contract execute error : " + e.getMessage()))

.build();

} catch (AccountResourceInsufficientException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.BANDWITH_ERROR)

.setMessage(ByteString.copyFromUtf8("Account resource insufficient error."))

.build();

} catch (DupTransactionException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.DUP_TRANSACTION_ERROR)

.setMessage(ByteString.copyFromUtf8("Dup transaction."))

.build();

} catch (TaposException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.TAPOS_ERROR)

.setMessage(ByteString.copyFromUtf8("Tapos check error."))

.build();

} catch (TooBigTransactionException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.TOO_BIG_TRANSACTION_ERROR)

.setMessage(ByteString.copyFromUtf8("Transaction size is too big."))

.build();

} catch (TransactionExpirationException e) {

logger.warn(BROADCAST_TRANS_FAILED, txID, e.getMessage());

return builder.setResult(false).setCode(response_code.TRANSACTION_EXPIRATION_ERROR)

.setMessage(ByteString.copyFromUtf8("Transaction expired"))

.build();

} catch (Exception e) {

logger.warn("Broadcast transaction {} failed", txID, e);

return builder.setResult(false).setCode(response_code.OTHER_ERROR)

.setMessage(ByteString.copyFromUtf8("Error: " + e.getMessage()))

.build();

}

}

public TransactionApprovedList getTransactionApprovedList(Transaction trx) {

TransactionApprovedList.Builder tswBuilder = TransactionApprovedList.newBuilder();

TransactionExtention.Builder trxExBuilder = TransactionExtention.newBuilder();

trxExBuilder.setTransaction(trx);

trxExBuilder.setTxid(ByteString.copyFrom(Sha256Hash.hash(CommonParameter

.getInstance().isECKeyCryptoEngine(), trx.getRawData().toByteArray())));

Return.Builder retBuilder = Return.newBuilder();

retBuilder.setResult(true).setCode(response_code.SUCCESS);

trxExBuilder.setResult(retBuilder);

tswBuilder.setTransaction(trxExBuilder);

TransactionApprovedList.Result.Builder resultBuilder = TransactionApprovedList.Result

.newBuilder();

if (trx.getRawData().getContractCount() == 0) {

resultBuilder.setCode(TransactionApprovedList.Result.response_code.OTHER_ERROR);

resultBuilder.setMessage("Invalid transaction: no valid contract");

} else {

try {

Contract contract = trx.getRawData().getContract(0);

byte[] owner = TransactionCapsule.getOwner(contract);

AccountCapsule account = chainBaseManager.getAccountStore().get(owner);

if (account == null) {

throw new PermissionException("Account does not exist!");

}

if (trx.getSignatureCount() > 0) {

List<ByteString> approveList = new ArrayList<ByteString>();

byte[] hash = Sha256Hash.hash(CommonParameter

.getInstance().isECKeyCryptoEngine(), trx.getRawData().toByteArray());

for (ByteString sig : trx.getSignatureList()) {

if (sig.size() < 65) {

throw new SignatureFormatException(

"Signature size is " + sig.size());

}

String base64 = TransactionCapsule.getBase64FromByteString(sig);

byte[] address = SignUtils.signatureToAddress(hash, base64, Args.getInstance()

.isECKeyCryptoEngine());

approveList.add(ByteString.copyFrom(address)); //out put approve list.

}

tswBuilder.addAllApprovedList(approveList);

}

resultBuilder.setCode(TransactionApprovedList.Result.response_code.SUCCESS);

} catch (SignatureFormatException signEx) {

resultBuilder.setCode(TransactionApprovedList.Result.response_code.SIGNATURE_FORMAT_ERROR);

resultBuilder.setMessage(signEx.getMessage());

} catch (SignatureException signEx) {

resultBuilder.setCode(TransactionApprovedList.Result.response_code.COMPUTE_ADDRESS_ERROR);

resultBuilder.setMessage(signEx.getMessage());

} catch (Exception ex) {

resultBuilder.setCode(TransactionApprovedList.Result.response_code.OTHER_ERROR);

resultBuilder.setMessage(ex.getClass() + " : " + ex.getMessage());

}

}

tswBuilder.setResult(resultBuilder);

return tswBuilder.build();

}

public Block getNowBlock() {

List<BlockCapsule> blockList = chainBaseManager.getBlockStore().getBlockByLatestNum(1);

if (CollectionUtils.isEmpty(blockList)) {

return null;

} else {

return blockList.get(0).getInstance();

}

}

public Block getBlockByNum(long blockNum) {

try {

return chainBaseManager.getBlockByNum(blockNum).getInstance();

} catch (StoreException e) {

logger.info(e.getMessage());

return null;

}

}

public BlockCapsule getBlockCapsuleByNum(long blockNum) {

try {

return chainBaseManager.getBlockByNum(blockNum);

} catch (StoreException e) {

logger.info(e.getMessage());

return null;

}

}

public long getTransactionCountByBlockNum(long blockNum) {

long count = 0;

try {

Block block = chainBaseManager.getBlockByNum(blockNum).getInstance();

count = block.getTransactionsCount();

} catch (StoreException e) {

logger.warn(e.getMessage());

}

return count;

}

public Block getByJsonBlockId(String id) throws JsonRpcInvalidParamsException {

if (EARLIEST_STR.equalsIgnoreCase(id)) {

return getBlockByNum(0);

} else if ("latest".equalsIgnoreCase(id)) {

return getNowBlock();

} else if ("pending".equalsIgnoreCase(id)) {

throw new JsonRpcInvalidParamsException("TAG pending not supported");

} else {

long blockNumber;

try {

blockNumber = ByteArray.hexToBigInteger(id).longValue();

} catch (Exception e) {

throw new JsonRpcInvalidParamsException("invalid block number");

}

return getBlockByNum(blockNumber);

}

}

public List<Transaction> getTransactionsByJsonBlockId(String id)

throws JsonRpcInvalidParamsException {

if ("pending".equalsIgnoreCase(id)) {

throw new JsonRpcInvalidParamsException("TAG pending not supported");

} else {

Block block = getByJsonBlockId(id);

return block != null ? block.getTransactionsList() : null;

}

}

public WitnessList getWitnessList() {

WitnessList.Builder builder = WitnessList.newBuilder();

List<WitnessCapsule> witnessCapsuleList = chainBaseManager.getWitnessStore().getAllWitnesses();

witnessCapsuleList

.forEach(witnessCapsule -> builder.addWitnesses(witnessCapsule.getInstance()));

return builder.build();

}

public ProposalList getProposalList() {

ProposalList.Builder builder = ProposalList.newBuilder();

List<ProposalCapsule> proposalCapsuleList =

chainBaseManager.getProposalStore().getAllProposals();

proposalCapsuleList

.forEach(proposalCapsule -> builder.addProposals(proposalCapsule.getInstance()));

return builder.build();

}

public DelegatedResourceList getDelegatedResource(ByteString fromAddress, ByteString toAddress) {

DelegatedResourceList.Builder builder = DelegatedResourceList.newBuilder();

byte[] dbKey = DelegatedResourceCapsule

.createDbKey(fromAddress.toByteArray(), toAddress.toByteArray());

DelegatedResourceCapsule delegatedResourceCapsule = chainBaseManager.getDelegatedResourceStore()

.get(dbKey);

if (delegatedResourceCapsule != null) {

builder.addDelegatedResource(delegatedResourceCapsule.getInstance());

}

return builder.build();

}

public DelegatedResourceList getDelegatedResourceV2(

ByteString fromAddress, ByteString toAddress) {

DelegatedResourceList.Builder builder = DelegatedResourceList.newBuilder();

byte[] dbKey = DelegatedResourceCapsule

.createDbKeyV2(fromAddress.toByteArray(), toAddress.toByteArray(), false);

DelegatedResourceCapsule unlockResource = chainBaseManager.getDelegatedResourceStore()

.get(dbKey);

if (nonEmptyResource(unlockResource)) {

builder.addDelegatedResource(unlockResource.getInstance());

}

dbKey = DelegatedResourceCapsule

.createDbKeyV2(fromAddress.toByteArray(), toAddress.toByteArray(), true);

DelegatedResourceCapsule lockResource = chainBaseManager.getDelegatedResourceStore()

.get(dbKey);

if (nonEmptyResource(lockResource)) {

builder.addDelegatedResource(lockResource.getInstance());

}

return builder.build();

}

private boolean nonEmptyResource(DelegatedResourceCapsule resource) {

return Objects.nonNull(resource) && !(resource.getExpireTimeForBandwidth() == 0

&& resource.getExpireTimeForEnergy() == 0

&& resource.getFrozenBalanceForBandwidth() == 0

&& resource.getFrozenBalanceForEnergy() == 0);

}

public GrpcAPI.CanWithdrawUnfreezeAmountResponseMessage getCanWithdrawUnfreezeAmount(

ByteString ownerAddress, long timestamp) {

GrpcAPI.CanWithdrawUnfreezeAmountResponseMessage.Builder builder =

GrpcAPI.CanWithdrawUnfreezeAmountResponseMessage.newBuilder();

if (timestamp < 0) {

return builder.build();

}

long canWithdrawUnfreezeAmount;

AccountStore accountStore = chainBaseManager.getAccountStore();

DynamicPropertiesStore dynamicStore = chainBaseManager.getDynamicPropertiesStore();

AccountCapsule accountCapsule = accountStore.get(ownerAddress.toByteArray());

if (accountCapsule == null) {

return builder.build();

}

if (timestamp == 0) {

timestamp = dynamicStore.getLatestBlockHeaderTimestamp();

}

List<UnFreezeV2> unfrozenV2List = accountCapsule.getInstance().getUnfrozenV2List();

long finalTimestamp = timestamp;

canWithdrawUnfreezeAmount = unfrozenV2List

.stream().filter(unfrozenV2 -> unfrozenV2.getUnfreezeExpireTime() <= finalTimestamp)

.mapToLong(UnFreezeV2::getUnfreezeAmount).sum();

builder.setAmount(canWithdrawUnfreezeAmount);

return builder.build();

}

public GrpcAPI.CanDelegatedMaxSizeResponseMessage getCanDelegatedMaxSize(

ByteString ownerAddress,

int resourceType) {

long canDelegatedMaxSize = 0L;

GrpcAPI.CanDelegatedMaxSizeResponseMessage.Builder builder =

GrpcAPI.CanDelegatedMaxSizeResponseMessage.newBuilder();

if (Common.ResourceCode.BANDWIDTH.getNumber() == resourceType) {

canDelegatedMaxSize = this.calcCanDelegatedBandWidthMaxSize(ownerAddress);

} else if (Common.ResourceCode.ENERGY.getNumber() == resourceType) {

canDelegatedMaxSize = this.calcCanDelegatedEnergyMaxSize(ownerAddress);

}

if (canDelegatedMaxSize < TRX_PRECISION) {

canDelegatedMaxSize = 0L;

}

builder.setMaxSize(canDelegatedMaxSize);

return builder.build();

}

public GrpcAPI.GetAvailableUnfreezeCountResponseMessage getAvailableUnfreezeCount(

ByteString ownerAddress) {

long getAvailableUnfreezeCount;

GrpcAPI.GetAvailableUnfreezeCountResponseMessage.Builder builder =

GrpcAPI.GetAvailableUnfreezeCountResponseMessage.newBuilder();

AccountStore accountStore = chainBaseManager.getAccountStore();

DynamicPropertiesStore dynamicStore = chainBaseManager.getDynamicPropertiesStore();

AccountCapsule accountCapsule = accountStore.get(ownerAddress.toByteArray());

if (accountCapsule == null) {

return builder.build();

}

long now = dynamicStore.getLatestBlockHeaderTimestamp();

long getUsedUnfreezeCount = accountCapsule.getUnfreezingV2Count(now);

getAvailableUnfreezeCount = UnfreezeBalanceV2Actuator.getUNFREEZE_MAX_TIMES()

- getUsedUnfreezeCount;

builder.setCount(getAvailableUnfreezeCount);

return builder.build();

}

public long calcCanDelegatedBandWidthMaxSize(

ByteString ownerAddress) {

AccountStore accountStore = chainBaseManager.getAccountStore();

DynamicPropertiesStore dynamicStore = chainBaseManager.getDynamicPropertiesStore();

AccountCapsule ownerCapsule = accountStore.get(ownerAddress.toByteArray());

if (ownerCapsule == null) {

return 0L;

}

BandwidthProcessor processor = new BandwidthProcessor(chainBaseManager);

processor.updateUsage(ownerCapsule);

long accountNetUsage = ownerCapsule.getNetUsage();

accountNetUsage += TransactionUtil.estimateConsumeBandWidthSize(dynamicStore,

ownerCapsule.getFrozenV2BalanceForBandwidth());

long netUsage = (long) (accountNetUsage * TRX_PRECISION * ((double)

(dynamicStore.getTotalNetWeight()) / dynamicStore.getTotalNetLimit()));

long v2NetUsage = getV2NetUsage(ownerCapsule, netUsage);

long maxSize = ownerCapsule.getFrozenV2BalanceForBandwidth() - v2NetUsage;

return Math.max(0, maxSize);

}

public long calcCanDelegatedEnergyMaxSize(ByteString ownerAddress) {

AccountStore accountStore = chainBaseManager.getAccountStore();

DynamicPropertiesStore dynamicStore = chainBaseManager.getDynamicPropertiesStore();

AccountCapsule ownerCapsule = accountStore.get(ownerAddress.toByteArray());

if (ownerCapsule == null) {

return 0L;

}

EnergyProcessor processor = new EnergyProcessor(dynamicStore, accountStore);

processor.updateUsage(ownerCapsule);

long energyUsage = (long) (ownerCapsule.getEnergyUsage() * TRX_PRECISION * ((double)

(dynamicStore.getTotalEnergyWeight()) / dynamicStore.getTotalEnergyCurrentLimit()));

long v2EnergyUsage = getV2EnergyUsage(ownerCapsule, energyUsage);

long maxSize = ownerCapsule.getFrozenV2BalanceForEnergy() - v2EnergyUsage;

return Math.max(0, maxSize);

}

public DelegatedResourceAccountIndex getDelegatedResourceAccountIndex(ByteString address) {

if (address == null || address.size() != DecodeUtil.ADDRESS_SIZE / 2) {

return DelegatedResourceAccountIndex.getDefaultInstance();

}

DelegatedResourceAccountIndexCapsule accountIndexCapsule =

chainBaseManager.getDelegatedResourceAccountIndexStore().getIndex(address.toByteArray());

if (accountIndexCapsule != null) {

return accountIndexCapsule.getInstance();

} else {

return DelegatedResourceAccountIndex.getDefaultInstance();

}

}

public DelegatedResourceAccountIndex getDelegatedResourceAccountIndexV2(ByteString address) {

if (address == null || address.size() != DecodeUtil.ADDRESS_SIZE / 2) {

return DelegatedResourceAccountIndex.getDefaultInstance();

}

DelegatedResourceAccountIndexCapsule accountIndexCapsule = chainBaseManager

.getDelegatedResourceAccountIndexStore().getV2Index(address.toByteArray());

if (accountIndexCapsule != null) {

return accountIndexCapsule.getInstance();

} else {

return DelegatedResourceAccountIndex.getDefaultInstance();

}

}

public ExchangeList getExchangeList() {

ExchangeList.Builder builder = ExchangeList.newBuilder();

List<ExchangeCapsule> exchangeCapsuleList =

getExchangeStoreFinal(chainBaseManager.getDynamicPropertiesStore(),

chainBaseManager.getExchangeStore(),

chainBaseManager.getExchangeV2Store()).getAllExchanges();

exchangeCapsuleList

.forEach(exchangeCapsule -> builder.addExchanges(exchangeCapsule.getInstance()));

return builder.build();

}

public Protocol.ChainParameters getChainParameters() {

Protocol.ChainParameters.Builder builder = Protocol.ChainParameters.newBuilder();

// MAINTENANCE_TIME_INTERVAL, //ms ,0

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMaintenanceTimeInterval")

.setValue(chainBaseManager.getDynamicPropertiesStore().getMaintenanceTimeInterval())

.build());

// ACCOUNT_UPGRADE_COST, //SUN ,1

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAccountUpgradeCost")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAccountUpgradeCost())

.build());

// CREATE_ACCOUNT_FEE, //SUN ,2

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getCreateAccountFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getCreateAccountFee())

.build());

// TRANSACTION_FEE, //SUN ,3

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getTransactionFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getTransactionFee())

.build());

// ASSET_ISSUE_FEE, //SUN ,4

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAssetIssueFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAssetIssueFee())

.build());

// WITNESS_PAY_PER_BLOCK, //SUN ,5

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getWitnessPayPerBlock")

.setValue(chainBaseManager.getDynamicPropertiesStore().getWitnessPayPerBlock())

.build());

// WITNESS_STANDBY_ALLOWANCE, //SUN ,6

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getWitnessStandbyAllowance")

.setValue(chainBaseManager.getDynamicPropertiesStore().getWitnessStandbyAllowance())

.build());

// CREATE_NEW_ACCOUNT_FEE_IN_SYSTEM_CONTRACT, //SUN ,7

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getCreateNewAccountFeeInSystemContract")

.setValue(chainBaseManager.getDynamicPropertiesStore()

.getCreateNewAccountFeeInSystemContract())

.build());

// CREATE_NEW_ACCOUNT_BANDWIDTH_RATE, // 1 ~ ,8

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getCreateNewAccountBandwidthRate")

.setValue(chainBaseManager.getDynamicPropertiesStore()

.getCreateNewAccountBandwidthRate()).build());

// ALLOW_CREATION_OF_CONTRACTS, // 0 / >0 ,9

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()