/*

* 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.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 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.spongycastle.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.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.overlay.discover.node.NodeHandler;

import org.tron.common.overlay.discover.node.NodeManager;

import org.tron.common.overlay.message.Message;

import org.tron.common.parameter.CommonParameter;

import org.tron.common.runtime.ProgramResult;

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.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.ActuatorFactory;

import org.tron.core.actuator.VMActuator;

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.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.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.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.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.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.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.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.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;

@Autowired

private NodeManager nodeManager;

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

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

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

@Autowired

private TransactionUtil transactionUtil;

/**

* Creates a new Wallet with a random ECKey.

*/

public Wallet() {

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

Args.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 ShieldAddress generateShieldAddress() {

// ShieldAddress.Builder builder = ShieldAddress.newBuilder();

// ShieldAddressGenerator shieldAddressGenerator = new ShieldAddressGenerator();

//

// byte[] privateKey = shieldAddressGenerator.generatePrivateKey();

// byte[] publicKey = shieldAddressGenerator.generatePublicKey(privateKey);

//

// byte[] privateKeyEnc = shieldAddressGenerator.generatePrivateKeyEnc(privateKey);

// byte[] publicKeyEnc = shieldAddressGenerator.generatePublicKeyEnc(privateKeyEnc);

//

// byte[] addPrivate = ByteUtil.merge(privateKey, privateKeyEnc);

// byte[] addPublic = ByteUtil.merge(publicKey, publicKeyEnc);

//

// builder.setPrivateAddress(ByteString.copyFrom(addPrivate));

// builder.setPublicAddress(ByteString.copyFrom(addPublic));

// return builder.build();

// }

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;

}

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

}

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;

}

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

if (contractType != ContractType.CreateSmartContract

&& contractType != ContractType.TriggerSmartContract) {

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

for (Actuator act : actList) {

act.validate();

}

}

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

try {

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

if (minEffectiveConnection != 0) {

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

logger

.warn("Broadcast transaction {} has failed, no connection.", trx.getTransactionId());

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, {}.", trx.getTransactionId(), 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.", trx.getTransactionId());

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

}

if (dbManager.getTransactionIdCache().getIfPresent(trx.getTransactionId()) != null) {

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

trx.getTransactionId());

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

} else {

dbManager.getTransactionIdCache().put(trx.getTransactionId(), true);

}

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

trx.resetResult();

}

dbManager.pushTransaction(trx);

tronNetService.broadcast(message);

logger.info("Broadcast transaction {} successfully.", trx.getTransactionId());

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

} catch (ValidateSignatureException e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

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

.build();

} catch (ContractValidateException e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), 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.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), 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.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

.setMessage(ByteString.copyFromUtf8("AccountResourceInsufficient error"))

.build();

} catch (DupTransactionException e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

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

.build();

} catch (TaposException e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

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

.build();

} catch (TooBigTransactionException e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), 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.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

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

.build();

} catch (Exception e) {

logger.error(BROADCAST_TRANS_FAILED, trx.getTransactionId(), e.getMessage());

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

.setMessage(ByteString.copyFromUtf8("other 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();

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 byte[] pass2Key(byte[] passPhrase) {

return Sha256Hash.hash(CommonParameter

.getInstance().isECKeyCryptoEngine(), passPhrase);

}

public byte[] createAddress(byte[] passPhrase) {

byte[] privateKey = pass2Key(passPhrase);

SignInterface ecKey = SignUtils.fromPrivate(privateKey,

Args.getInstance().isECKeyCryptoEngine());

return ecKey.getAddress();

}

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 long getTransactionCountByBlockNum(long blockNum) {

long count = 0;

try {

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

count = block.getTransactionsCount();

} catch (StoreException e) {

logger.error(e.getMessage());

}

return count;

}

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 DelegatedResourceAccountIndex getDelegatedResourceAccountIndex(ByteString address) {

DelegatedResourceAccountIndexCapsule accountIndexCapsule =

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

if (accountIndexCapsule != null) {

return accountIndexCapsule.getInstance();

} else {

return null;

}

}

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

.setKey("getAllowCreationOfContracts")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowCreationOfContracts())

.build());

// REMOVE_THE_POWER_OF_THE_GR, // 1 ,10

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getRemoveThePowerOfTheGr")

.setValue(chainBaseManager.getDynamicPropertiesStore().getRemoveThePowerOfTheGr())

.build());

// ENERGY_FEE, // SUN, 11

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getEnergyFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getEnergyFee())

.build());

// EXCHANGE_CREATE_FEE, // SUN, 12

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getExchangeCreateFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getExchangeCreateFee())

.build());

// MAX_CPU_TIME_OF_ONE_TX, // ms, 13

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMaxCpuTimeOfOneTx")

.setValue(chainBaseManager.getDynamicPropertiesStore().getMaxCpuTimeOfOneTx())

.build());

// ALLOW_UPDATE_ACCOUNT_NAME, // 1, 14

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowUpdateAccountName")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowUpdateAccountName())

.build());

// ALLOW_SAME_TOKEN_NAME, // 1, 15

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowSameTokenName")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowSameTokenName())

.build());

// ALLOW_DELEGATE_RESOURCE, // 0, 16

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowDelegateResource")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowDelegateResource())

.build());

// TOTAL_ENERGY_LIMIT, // 50,000,000,000, 17

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getTotalEnergyLimit")

.setValue(chainBaseManager.getDynamicPropertiesStore().getTotalEnergyLimit())

.build());

// ALLOW_TVM_TRANSFER_TRC10, // 1, 18

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowTvmTransferTrc10")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowTvmTransferTrc10())

.build());

// TOTAL_CURRENT_ENERGY_LIMIT, // 50,000,000,000, 19

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getTotalEnergyCurrentLimit")

.setValue(chainBaseManager.getDynamicPropertiesStore().getTotalEnergyCurrentLimit())

.build());

// ALLOW_MULTI_SIGN, // 1, 20

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowMultiSign")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowMultiSign())

.build());

// ALLOW_ADAPTIVE_ENERGY, // 1, 21

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowAdaptiveEnergy")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowAdaptiveEnergy())

.build());

//other chainParameters

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getTotalEnergyTargetLimit")

.setValue(chainBaseManager.getDynamicPropertiesStore().getTotalEnergyTargetLimit())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getTotalEnergyAverageUsage")

.setValue(chainBaseManager.getDynamicPropertiesStore().getTotalEnergyAverageUsage())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getUpdateAccountPermissionFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getUpdateAccountPermissionFee())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMultiSignFee")

.setValue(chainBaseManager.getDynamicPropertiesStore().getMultiSignFee())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowAccountStateRoot")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowAccountStateRoot())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowProtoFilterNum")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowProtoFilterNum())

.build());

// ALLOW_TVM_CONSTANTINOPLE

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowTvmConstantinople")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowTvmConstantinople())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowTvmSolidity059")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAllowTvmSolidity059())

.build());

// ALLOW_TVM_ISTANBUL

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder().setKey("getAllowTvmIstanbul")

.setValue(dbManager.getDynamicPropertiesStore().getAllowTvmIstanbul()).build());

// ALLOW_ZKSNARK_TRANSACTION

// builder.addChainParameter(

// Protocol.ChainParameters.ChainParameter.newBuilder()

// .setKey("getAllowShieldedTransaction")

// .setValue(dbManager.getDynamicPropertiesStore().getAllowShieldedTransaction())

// .build());

//

// // SHIELDED_TRANSACTION_FEE

// builder.addChainParameter(

// Protocol.ChainParameters.ChainParameter.newBuilder()

// .setKey("getShieldedTransactionFee")

// .setValue(dbManager.getDynamicPropertiesStore().getShieldedTransactionFee())

// .build());

//

// // ShieldedTransactionCreateAccountFee

// builder.addChainParameter(

// Protocol.ChainParameters.ChainParameter.newBuilder()

// .setKey("getShieldedTransactionCreateAccountFee")

// .setValue(

// dbManager.getDynamicPropertiesStore()

// .getShieldedTransactionCreateAccountFee())

// .build());

// ALLOW_SHIELDED_TRC20_TRANSACTION

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowShieldedTRC20Transaction")

.setValue(

dbManager.getDynamicPropertiesStore().getAllowShieldedTRC20Transaction())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getForbidTransferToContract")

.setValue(dbManager.getDynamicPropertiesStore().getForbidTransferToContract())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAdaptiveResourceLimitTargetRatio")

.setValue(

chainBaseManager.getDynamicPropertiesStore()

.getAdaptiveResourceLimitTargetRatio() / (24 * 60)).build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAdaptiveResourceLimitMultiplier")

.setValue(chainBaseManager.getDynamicPropertiesStore().getAdaptiveResourceLimitMultiplier())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getChangeDelegation")

.setValue(chainBaseManager.getDynamicPropertiesStore().getChangeDelegation())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getWitness127PayPerBlock")

.setValue(chainBaseManager.getDynamicPropertiesStore().getWitness127PayPerBlock())

.build());

builder.addChainParameter(

Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowMarketTransaction")

.setValue(dbManager.getDynamicPropertiesStore().getAllowMarketTransaction())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMarketSellFee")

.setValue(dbManager.getDynamicPropertiesStore().getMarketSellFee())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMarketCancelFee")

.setValue(dbManager.getDynamicPropertiesStore().getMarketCancelFee())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowPBFT")

.setValue(dbManager.getDynamicPropertiesStore().getAllowPBFT())

.build());

//builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

// .setKey("getAllowTvmStake")

// .setValue(dbManager.getDynamicPropertiesStore().getAllowTvmStake())

// .build());

//builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

// .setKey("getAllowTvmAssetIssue")

// .setValue(dbManager.getDynamicPropertiesStore().getAllowTvmAssetIssue())

// .build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowTransactionFeePool")

.setValue(dbManager.getDynamicPropertiesStore().getAllowTransactionFeePool())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getMaxFeeLimit")

.setValue(dbManager.getDynamicPropertiesStore().getMaxFeeLimit())

.build());

builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()

.setKey("getAllowOptimizeBlackHole")

.setValue(dbManager.getDynamicPropertiesStore().getAllowBlackHoleOptimization())

.build());