package org.tron.core.db;

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

import static org.tron.core.config.Parameter.NodeConstant.MAX_TRANSACTION_PENDING;

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

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

import com.google.common.cache.Cache;

import com.google.common.cache.CacheBuilder;

import com.google.common.collect.Lists;

import com.google.protobuf.ByteString;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.TimeUnit;

import java.util.stream.Collectors;

import javafx.util.Pair;

import javax.annotation.PostConstruct;

import lombok.Getter;

import lombok.Setter;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.collections4.CollectionUtils;

import org.joda.time.DateTime;

import org.spongycastle.util.encoders.Hex;

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

import org.springframework.stereotype.Component;

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

import org.tron.common.runtime.Runtime;

import org.tron.common.runtime.vm.program.invoke.ProgramInvokeFactoryImpl;

import org.tron.common.storage.DepositImpl;

import org.tron.common.utils.ByteArray;

import org.tron.common.utils.ForkController;

import org.tron.common.utils.SessionOptional;

import org.tron.common.utils.Sha256Hash;

import org.tron.common.utils.StringUtil;

import org.tron.common.utils.Time;

import org.tron.core.Constant;

import org.tron.core.capsule.AccountCapsule;

import org.tron.core.capsule.BlockCapsule;

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

import org.tron.core.capsule.BytesCapsule;

import org.tron.core.capsule.ReceiptCapsule;

import org.tron.core.capsule.TransactionCapsule;

import org.tron.core.capsule.TransactionInfoCapsule;

import org.tron.core.capsule.TransactionResultCapsule;

import org.tron.core.capsule.WitnessCapsule;

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

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

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

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

import org.tron.core.db.KhaosDatabase.KhaosBlock;

import org.tron.core.db2.core.ISession;

import org.tron.core.db2.core.ITronChainBase;

import org.tron.core.exception.AccountResourceInsufficientException;

import org.tron.core.exception.BadBlockException;

import org.tron.core.exception.BadItemException;

import org.tron.core.exception.BadNumberBlockException;

import org.tron.core.exception.BalanceInsufficientException;

import org.tron.core.exception.ContractExeException;

import org.tron.core.exception.ContractSizeNotEqualToOneException;

import org.tron.core.exception.ContractValidateException;

import org.tron.core.exception.DupTransactionException;

import org.tron.core.exception.HeaderNotFound;

import org.tron.core.exception.HighFreqException;

import org.tron.core.exception.ItemNotFoundException;

import org.tron.core.exception.NonCommonBlockException;

import org.tron.core.exception.OutOfSlotTimeException;

import org.tron.core.exception.ReceiptException;

import org.tron.core.exception.TaposException;

import org.tron.core.exception.TooBigTransactionException;

import org.tron.core.exception.TransactionExpirationException;

import org.tron.core.exception.TransactionTraceException;

import org.tron.core.exception.UnLinkedBlockException;

import org.tron.core.exception.UnsupportVMException;

import org.tron.core.exception.ValidateScheduleException;

import org.tron.core.exception.ValidateSignatureException;

import org.tron.core.witness.ProposalController;

import org.tron.core.witness.WitnessController;

import org.tron.protos.Protocol.AccountType;

import org.tron.protos.Protocol.Block;

import org.tron.protos.Protocol.Transaction;

@Slf4j

@Component

public class Manager {

// db store

@Autowired

private AccountStore accountStore;

@Autowired

private TransactionStore transactionStore;

@Autowired

private BlockStore blockStore;

@Autowired

private WitnessStore witnessStore;

@Autowired

private AssetIssueStore assetIssueStore;

@Autowired

private DynamicPropertiesStore dynamicPropertiesStore;

@Autowired

private BlockIndexStore blockIndexStore;

@Autowired

private AccountIdIndexStore accountIdIndexStore;

@Autowired

private WitnessScheduleStore witnessScheduleStore;

@Autowired

private RecentBlockStore recentBlockStore;

@Autowired

private VotesStore votesStore;

@Autowired

private ProposalStore proposalStore;

@Autowired

private ExchangeStore exchangeStore;

@Autowired

private TransactionHistoryStore transactionHistoryStore;

@Autowired

private CodeStore codeStore;

@Autowired

private ContractStore contractStore;

@Autowired

@Getter

private StorageRowStore storageRowStore;

// for network

@Autowired

private PeersStore peersStore;

@Autowired

private KhaosDatabase khaosDb;

private BlockCapsule genesisBlock;

@Getter

@Autowired

private RevokingDatabase revokingStore;

@Getter

private SessionOptional session = SessionOptional.instance();

@Getter

@Setter

private boolean isSyncMode;

@Getter

@Setter

private String netType;

@Getter

@Setter

private WitnessController witnessController;

@Getter

@Setter

private ProposalController proposalController;

private ExecutorService validateSignService;

private Thread repushThread;

private boolean isRunRepushThread = true;

@Getter

private Cache<Sha256Hash, Boolean> transactionIdCache = CacheBuilder

.newBuilder().maximumSize(100_000).recordStats().build();

@Getter

@Autowired

private ForkController forkController;

public WitnessStore getWitnessStore() {

return this.witnessStore;

}

private void setWitnessStore(final WitnessStore witnessStore) {

this.witnessStore = witnessStore;

}

public DynamicPropertiesStore getDynamicPropertiesStore() {

return this.dynamicPropertiesStore;

}

public void setDynamicPropertiesStore(final DynamicPropertiesStore dynamicPropertiesStore) {

this.dynamicPropertiesStore = dynamicPropertiesStore;

}

public WitnessScheduleStore getWitnessScheduleStore() {

return this.witnessScheduleStore;

}

public void setWitnessScheduleStore(final WitnessScheduleStore witnessScheduleStore) {

this.witnessScheduleStore = witnessScheduleStore;

}

public CodeStore getCodeStore() {

return codeStore;

}

public ContractStore getContractStore() {

return contractStore;

}

public VotesStore getVotesStore() {

return this.votesStore;

}

public ProposalStore getProposalStore() {

return this.proposalStore;

}

public ExchangeStore getExchangeStore() {

return this.exchangeStore;

}

public List<TransactionCapsule> getPendingTransactions() {

return this.pendingTransactions;

}

public List<TransactionCapsule> getPoppedTransactions() {

return this.popedTransactions;

}

public BlockingQueue<TransactionCapsule> getRepushTransactions() {

return repushTransactions;

}

// transactions cache

private List<TransactionCapsule> pendingTransactions;

// transactions popped

private List<TransactionCapsule> popedTransactions =

Collections.synchronizedList(Lists.newArrayList());

// the capacity is equal to Integer.MAX_VALUE default

private BlockingQueue<TransactionCapsule> repushTransactions;

// for test only

public List<ByteString> getWitnesses() {

return witnessController.getActiveWitnesses();

}

// for test only

public void addWitness(final ByteString address) {

List<ByteString> witnessAddresses = witnessController.getActiveWitnesses();

witnessAddresses.add(address);

witnessController.setActiveWitnesses(witnessAddresses);

}

public BlockCapsule getHead() throws HeaderNotFound {

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

if (CollectionUtils.isNotEmpty(blocks)) {

return blocks.get(0);

} else {

logger.info("Header block Not Found");

throw new HeaderNotFound("Header block Not Found");

}

}

public synchronized BlockId getHeadBlockId() {

return new BlockId(

getDynamicPropertiesStore().getLatestBlockHeaderHash(),

getDynamicPropertiesStore().getLatestBlockHeaderNumber());

}

public long getHeadBlockNum() {

return getDynamicPropertiesStore().getLatestBlockHeaderNumber();

}

public long getHeadBlockTimeStamp() {

return getDynamicPropertiesStore().getLatestBlockHeaderTimestamp();

}

// public PeersStore getPeersStore() {

// return peersStore;

// }

//

// public void setPeersStore(PeersStore peersStore) {

// this.peersStore = peersStore;

// }

//

// public Node getHomeNode() {

// final Args args = Args.getInstance();

// Set<Node> nodes = this.peersStore.get("home".getBytes());

// if (nodes.size() > 0) {

// return nodes.stream().findFirst().get();

// } else {

// Node node =

// new Node(new ECKey().getNodeId(), args.getNodeExternalIp(), args.getNodeListenPort());

// nodes.add(node);

// this.peersStore.put("home".getBytes(), nodes);

// return node;

// }

// }

public void clearAndWriteNeighbours(Set<Node> nodes) {

this.peersStore.put("neighbours".getBytes(), nodes);

}

public Set<Node> readNeighbours() {

return this.peersStore.get("neighbours".getBytes());

}

/**

* Cycle thread to repush Transactions

*/

private Runnable repushLoop =

() -> {

while (isRunRepushThread) {

try {

TransactionCapsule tx = this.getRepushTransactions().poll(1, TimeUnit.SECONDS);

if (tx != null) {

this.rePush(tx);

}

} catch (InterruptedException ex) {

logger.error(ex.getMessage());

Thread.currentThread().interrupt();

} catch (Exception ex) {

logger.error("unknown exception happened in witness loop", ex);

} catch (Throwable throwable) {

logger.error("unknown throwable happened in witness loop", throwable);

}

}

};

public void stopRepushThread() {

isRunRepushThread = false;

}

@PostConstruct

public void init() {

revokingStore.disable();

revokingStore.check();

this.setWitnessController(WitnessController.createInstance(this));

this.setProposalController(ProposalController.createInstance(this));

this.pendingTransactions = Collections.synchronizedList(Lists.newArrayList());

this.repushTransactions = new LinkedBlockingQueue<>();

this.initGenesis();

try {

this.khaosDb.start(getBlockById(getDynamicPropertiesStore().getLatestBlockHeaderHash()));

} catch (ItemNotFoundException e) {

logger.error(

"Can not find Dynamic highest block from DB! \nnumber={} \nhash={}",

getDynamicPropertiesStore().getLatestBlockHeaderNumber(),

getDynamicPropertiesStore().getLatestBlockHeaderHash());

logger.error(

"Please delete database directory({}) and restart",

Args.getInstance().getOutputDirectory());

System.exit(1);

} catch (BadItemException e) {

e.printStackTrace();

logger.error("DB data broken!");

logger.error(

"Please delete database directory({}) and restart",

Args.getInstance().getOutputDirectory());

System.exit(1);

}

forkController.init(this);

revokingStore.enable();

// this.codeStore = CodeStore.create("code");

// this.contractStore = ContractStore.create("contract");

// this.storageStore = StorageStore.create("storage");

validateSignService = Executors

.newFixedThreadPool(Args.getInstance().getValidateSignThreadNum());

repushThread = new Thread(repushLoop);

repushThread.start();

}

public BlockId getGenesisBlockId() {

return this.genesisBlock.getBlockId();

}

public BlockCapsule getGenesisBlock() {

return genesisBlock;

}

/**

* init genesis block.

*/

public void initGenesis() {

this.genesisBlock = BlockUtil.newGenesisBlockCapsule();

if (this.containBlock(this.genesisBlock.getBlockId())) {

Args.getInstance().setChainId(this.genesisBlock.getBlockId().toString());

} else {

if (this.hasBlocks()) {

logger.error(

"genesis block modify, please delete database directory({}) and restart",

Args.getInstance().getOutputDirectory());

System.exit(1);

} else {

logger.info("create genesis block");

Args.getInstance().setChainId(this.genesisBlock.getBlockId().toString());

// this.pushBlock(this.genesisBlock);

blockStore.put(this.genesisBlock.getBlockId().getBytes(), this.genesisBlock);

this.blockIndexStore.put(this.genesisBlock.getBlockId());

logger.info("save block: " + this.genesisBlock);

// init DynamicPropertiesStore

this.dynamicPropertiesStore.saveLatestBlockHeaderNumber(0);

this.dynamicPropertiesStore.saveLatestBlockHeaderHash(

this.genesisBlock.getBlockId().getByteString());

this.dynamicPropertiesStore.saveLatestBlockHeaderTimestamp(

this.genesisBlock.getTimeStamp());

this.initAccount();

this.initWitness();

this.witnessController.initWits();

this.khaosDb.start(genesisBlock);

this.updateRecentBlock(genesisBlock);

}

}

}

/**

* save account into database.

*/

public void initAccount() {

final Args args = Args.getInstance();

final GenesisBlock genesisBlockArg = args.getGenesisBlock();

genesisBlockArg

.getAssets()

.forEach(

account -> {

account.setAccountType("Normal"); // to be set in conf

final AccountCapsule accountCapsule =

new AccountCapsule(

account.getAccountName(),

ByteString.copyFrom(account.getAddress()),

account.getAccountType(),

account.getBalance());

this.accountStore.put(account.getAddress(), accountCapsule);

this.accountIdIndexStore.put(accountCapsule);

});

}

/**

* save witnesses into database.

*/

private void initWitness() {

final Args args = Args.getInstance();

final GenesisBlock genesisBlockArg = args.getGenesisBlock();

genesisBlockArg

.getWitnesses()

.forEach(

key -> {

byte[] keyAddress = key.getAddress();

ByteString address = ByteString.copyFrom(keyAddress);

final AccountCapsule accountCapsule;

if (!this.accountStore.has(keyAddress)) {

accountCapsule = new AccountCapsule(ByteString.EMPTY,

address, AccountType.AssetIssue, 0L);

} else {

accountCapsule = this.accountStore.getUnchecked(keyAddress);

}

accountCapsule.setIsWitness(true);

this.accountStore.put(keyAddress, accountCapsule);

final WitnessCapsule witnessCapsule =

new WitnessCapsule(address, key.getVoteCount(), key.getUrl());

witnessCapsule.setIsJobs(true);

this.witnessStore.put(keyAddress, witnessCapsule);

});

}

public AccountStore getAccountStore() {

return this.accountStore;

}

public void adjustBalance(byte[] accountAddress, long amount)

throws BalanceInsufficientException {

AccountCapsule account = getAccountStore().getUnchecked(accountAddress);

adjustBalance(account, amount);

}

/**

* judge balance.

*/

public void adjustBalance(AccountCapsule account, long amount)

throws BalanceInsufficientException {

long balance = account.getBalance();

if (amount == 0) {

return;

}

if (amount < 0 && balance < -amount) {

throw new BalanceInsufficientException(

StringUtil.createReadableString(account.createDbKey()) + " insufficient balance");

}

account.setBalance(Math.addExact(balance, amount));

this.getAccountStore().put(account.getAddress().toByteArray(), account);

}

public void adjustAllowance(byte[] accountAddress, long amount)

throws BalanceInsufficientException {

AccountCapsule account = getAccountStore().getUnchecked(accountAddress);

long allowance = account.getAllowance();

if (amount == 0) {

return;

}

if (amount < 0 && allowance < -amount) {

throw new BalanceInsufficientException(

StringUtil.createReadableString(accountAddress) + " insufficient balance");

}

account.setAllowance(allowance + amount);

this.getAccountStore().put(account.createDbKey(), account);

}

void validateTapos(TransactionCapsule transactionCapsule) throws TaposException {

byte[] refBlockHash = transactionCapsule.getInstance()

.getRawData().getRefBlockHash().toByteArray();

byte[] refBlockNumBytes = transactionCapsule.getInstance()

.getRawData().getRefBlockBytes().toByteArray();

try {

byte[] blockHash = this.recentBlockStore.get(refBlockNumBytes).getData();

if (Arrays.equals(blockHash, refBlockHash)) {

return;

} else {

String str = String.format(

"Tapos failed, different block hash, %s, %s , recent block %s, solid block %s head block %s",

ByteArray.toLong(refBlockNumBytes), Hex.toHexString(refBlockHash),

Hex.toHexString(blockHash),

getSolidBlockId().getString(), getHeadBlockId().getString()).toString();

logger.info(str);

throw new TaposException(str);

}

} catch (ItemNotFoundException e) {

String str = String.

format("Tapos failed, block not found, ref block %s, %s , solid block %s head block %s",

ByteArray.toLong(refBlockNumBytes), Hex.toHexString(refBlockHash),

getSolidBlockId().getString(), getHeadBlockId().getString()).toString();

logger.info(str);

throw new TaposException(str);

}

}

void validateCommon(TransactionCapsule transactionCapsule)

throws TransactionExpirationException, TooBigTransactionException {

if (transactionCapsule.getData().length > Constant.TRANSACTION_MAX_BYTE_SIZE) {

throw new TooBigTransactionException(

"too big transaction, the size is " + transactionCapsule.getData().length + " bytes");

}

long transactionExpiration = transactionCapsule.getExpiration();

long headBlockTime = getHeadBlockTimeStamp();

if (transactionExpiration <= headBlockTime ||

transactionExpiration > headBlockTime + Constant.MAXIMUM_TIME_UNTIL_EXPIRATION) {

throw new TransactionExpirationException(

"transaction expiration, transaction expiration time is " + transactionExpiration

+ ", but headBlockTime is " + headBlockTime);

}

}

void validateDup(TransactionCapsule transactionCapsule) throws DupTransactionException {

if (getTransactionStore().getUnchecked(transactionCapsule.getTransactionId().getBytes())

!= null) {

logger.debug(ByteArray.toHexString(transactionCapsule.getTransactionId().getBytes()));

throw new DupTransactionException("dup trans");

}

}

/**

* push transaction into pending.

*/

public boolean pushTransaction(final TransactionCapsule trx)

throws ValidateSignatureException, ContractValidateException, ContractExeException,

AccountResourceInsufficientException, DupTransactionException, TaposException,

TooBigTransactionException, TransactionExpirationException, ReceiptException,

TransactionTraceException, OutOfSlotTimeException, UnsupportVMException {

if (!trx.validateSignature()) {

throw new ValidateSignatureException("trans sig validate failed");

}

//validateFreq(trx);

synchronized (this) {

if (!session.valid()) {

session.setValue(revokingStore.buildSession());

}

try (ISession tmpSession = revokingStore.buildSession()) {

processTransaction(trx, null);

pendingTransactions.add(trx);

tmpSession.merge();

}

}

return true;

}

public void consumeBandwidth(TransactionCapsule trx, TransactionResultCapsule ret,

TransactionTrace trace)

throws ContractValidateException, AccountResourceInsufficientException {

BandwidthProcessor processor = new BandwidthProcessor(this);

processor.consume(trx, ret, trace);

}

public void consumeEnergy(TransactionCapsule trx, TransactionResultCapsule ret,

TransactionTrace trace)

throws ContractValidateException, AccountResourceInsufficientException {

EnergyProcessor processor = new EnergyProcessor(this);

processor.consume(trx, ret, trace);

}

@Deprecated

private void validateFreq(TransactionCapsule trx) throws HighFreqException {

List<org.tron.protos.Protocol.Transaction.Contract> contracts =

trx.getInstance().getRawData().getContractList();

for (Transaction.Contract contract : contracts) {

if (contract.getType() == TransferContract || contract.getType() == TransferAssetContract) {

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

AccountCapsule accountCapsule = this.getAccountStore().getUnchecked(address);

if (accountCapsule == null) {

throw new HighFreqException("account not exists");

}

long balance = accountCapsule.getBalance();

long latestOperationTime = accountCapsule.getLatestOperationTime();

if (latestOperationTime != 0) {

doValidateFreq(balance, 0, latestOperationTime);

}

accountCapsule.setLatestOperationTime(Time.getCurrentMillis());

this.getAccountStore().put(accountCapsule.createDbKey(), accountCapsule);

}

}

}

@Deprecated

private void doValidateFreq(long balance, int transNumber, long latestOperationTime)

throws HighFreqException {

long now = Time.getCurrentMillis();

// todo: avoid ddos, design more smoothly formula later.

if (balance < 1000000 * 1000) {

if (now - latestOperationTime < 5 * 60 * 1000) {

throw new HighFreqException("try later");

}

}

}

/**

* when switch fork need erase blocks on fork branch.

*/

public void eraseBlock() {

session.reset();

try {

BlockCapsule oldHeadBlock = getBlockById(

getDynamicPropertiesStore().getLatestBlockHeaderHash());

logger.info("begin to erase block:" + oldHeadBlock);

khaosDb.pop();

revokingStore.pop();

logger.info("end to erase block:" + oldHeadBlock);

popedTransactions.addAll(oldHeadBlock.getTransactions());

// todo: need add ??

// repushTransactions.addAll(oldHeadBlock.getTransactions());

//

} catch (ItemNotFoundException | BadItemException e) {

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

}

}

private void applyBlock(BlockCapsule block) throws ContractValidateException,

ContractExeException, ValidateSignatureException, AccountResourceInsufficientException,

TransactionExpirationException, TooBigTransactionException, DupTransactionException, ReceiptException,

TaposException, ValidateScheduleException, TransactionTraceException, OutOfSlotTimeException,

UnsupportVMException {

processBlock(block);

this.blockStore.put(block.getBlockId().getBytes(), block);

this.blockIndexStore.put(block.getBlockId());

updateFork();

}

private void switchFork(BlockCapsule newHead)

throws ValidateSignatureException, ContractValidateException, ContractExeException,

ValidateScheduleException, AccountResourceInsufficientException, TaposException,

TooBigTransactionException, DupTransactionException, TransactionExpirationException,

NonCommonBlockException, ReceiptException, TransactionTraceException, OutOfSlotTimeException,

UnsupportVMException {

Pair<LinkedList<KhaosBlock>, LinkedList<KhaosBlock>> binaryTree;

try {

binaryTree =

khaosDb.getBranch(

newHead.getBlockId(), getDynamicPropertiesStore().getLatestBlockHeaderHash());

} catch (NonCommonBlockException e) {

logger.info(

"there is not the most recent common ancestor, need to remove all blocks in the fork chain.");

BlockCapsule tmp = newHead;

while (tmp != null) {

khaosDb.removeBlk(tmp.getBlockId());

tmp = khaosDb.getBlock(tmp.getParentHash());

}

throw e;

}

if (CollectionUtils.isNotEmpty(binaryTree.getValue())) {

while (!getDynamicPropertiesStore()

.getLatestBlockHeaderHash()

.equals(binaryTree.getValue().peekLast().getParentHash())) {

eraseBlock();

}

}

if (CollectionUtils.isNotEmpty(binaryTree.getKey())) {

List<KhaosBlock> first = new ArrayList<>(binaryTree.getKey());

Collections.reverse(first);

for (KhaosBlock item : first) {

Exception exception = null;

// todo process the exception carefully later

try (ISession tmpSession = revokingStore.buildSession()) {

applyBlock(item.getBlk());

tmpSession.commit();

} catch (AccountResourceInsufficientException

| ValidateSignatureException

| ContractValidateException

| ContractExeException

| TaposException

| DupTransactionException

| TransactionExpirationException

| TransactionTraceException

| ReceiptException

| OutOfSlotTimeException

| TooBigTransactionException

| ValidateScheduleException

| UnsupportVMException e) {

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

exception = e;

throw e;

} finally {

if (exception != null) {

logger.warn("switch back because exception thrown while switching forks. " + exception

.getMessage(),

exception);

first.forEach(khaosBlock -> khaosDb.removeBlk(khaosBlock.getBlk().getBlockId()));

khaosDb.setHead(binaryTree.getValue().peekFirst());

while (!getDynamicPropertiesStore()

.getLatestBlockHeaderHash()

.equals(binaryTree.getValue().peekLast().getParentHash())) {

eraseBlock();

}

List<KhaosBlock> second = new ArrayList<>(binaryTree.getValue());

Collections.reverse(second);

for (KhaosBlock khaosBlock : second) {

// todo process the exception carefully later

try (ISession tmpSession = revokingStore.buildSession()) {

applyBlock(khaosBlock.getBlk());

tmpSession.commit();

} catch (AccountResourceInsufficientException

| ValidateSignatureException

| ContractValidateException

| ContractExeException

| TaposException

| DupTransactionException

| TransactionExpirationException

| TooBigTransactionException

| ValidateScheduleException e) {

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

}

}

}

}

}

}

}

// TODO: if error need to rollback.

private synchronized void filterPendingTrx(List<TransactionCapsule> listTrx) {

}

/**

* save a block.

*/

public synchronized void pushBlock(final BlockCapsule block)

throws ValidateSignatureException, ContractValidateException, ContractExeException,

UnLinkedBlockException, ValidateScheduleException, AccountResourceInsufficientException,

TaposException, TooBigTransactionException, DupTransactionException, TransactionExpirationException,

BadNumberBlockException, BadBlockException, NonCommonBlockException, ReceiptException, TransactionTraceException,

OutOfSlotTimeException, UnsupportVMException {

try (PendingManager pm = new PendingManager(this)) {

if (!block.generatedByMyself) {

if (!block.validateSignature()) {

logger.warn("The signature is not validated.");

throw new BadBlockException("The signature is not validated");

}

if (!block.calcMerkleRoot().equals(block.getMerkleRoot())) {

logger.warn(

"The merkle root doesn't match, Calc result is "

+ block.calcMerkleRoot()

+ " , the headers is "

+ block.getMerkleRoot());

throw new BadBlockException("The merkle hash is not validated");

}

}

BlockCapsule newBlock = this.khaosDb.push(block);

// DB don't need lower block

if (getDynamicPropertiesStore().getLatestBlockHeaderHash() == null) {

if (newBlock.getNum() != 0) {

return;

}

} else {

if (newBlock.getNum() <= getDynamicPropertiesStore().getLatestBlockHeaderNumber()) {

return;

}

// switch fork

if (!newBlock

.getParentHash()

.equals(getDynamicPropertiesStore().getLatestBlockHeaderHash())) {

logger.warn(

"switch fork! new head num = {}, blockid = {}",

newBlock.getNum(),

newBlock.getBlockId());

logger.warn(

"******** before switchFork ******* push block: "

+ block.getShortString()

+ ", new block:"

+ newBlock.getShortString()

+ ", dynamic head num: "

+ dynamicPropertiesStore.getLatestBlockHeaderNumber()

+ ", dynamic head hash: "

+ dynamicPropertiesStore.getLatestBlockHeaderHash()

+ ", dynamic head timestamp: "

+ dynamicPropertiesStore.getLatestBlockHeaderTimestamp()

+ ", khaosDb head: "

+ khaosDb.getHead()

+ ", khaosDb miniStore size: "

+ khaosDb.getMiniStore().size()

+ ", khaosDb unlinkMiniStore size: "

+ khaosDb.getMiniUnlinkedStore().size());

switchFork(newBlock);

logger.info("save block: " + newBlock);

logger.warn(

"******** after switchFork ******* push block: "

+ block.getShortString()

+ ", new block:"

+ newBlock.getShortString()

+ ", dynamic head num: "

+ dynamicPropertiesStore.getLatestBlockHeaderNumber()

+ ", dynamic head hash: "

+ dynamicPropertiesStore.getLatestBlockHeaderHash()

+ ", dynamic head timestamp: "

+ dynamicPropertiesStore.getLatestBlockHeaderTimestamp()

+ ", khaosDb head: "

+ khaosDb.getHead()

+ ", khaosDb miniStore size: "

+ khaosDb.getMiniStore().size()

+ ", khaosDb unlinkMiniStore size: "

+ khaosDb.getMiniUnlinkedStore().size());

return;

}

try (ISession tmpSession = revokingStore.buildSession()) {

applyBlock(newBlock);

tmpSession.commit();

} catch (Throwable throwable) {

logger.error(throwable.getMessage(), throwable);

khaosDb.removeBlk(block.getBlockId());

throw throwable;

}

}

logger.info("save block: " + newBlock);

}

}

public void updateDynamicProperties(BlockCapsule block) {

long slot = 1;

if (block.getNum() != 1) {

slot = witnessController.getSlotAtTime(block.getTimeStamp());

}

for (int i = 1; i < slot; ++i) {

if (!witnessController.getScheduledWitness(i).equals(block.getWitnessAddress())) {

WitnessCapsule w =

this.witnessStore

.getUnchecked(StringUtil.createDbKey(witnessController.getScheduledWitness(i)));

w.setTotalMissed(w.getTotalMissed() + 1);

this.witnessStore.put(w.createDbKey(), w);

logger.info(

"{} miss a block. totalMissed = {}", w.createReadableString(), w.getTotalMissed());

}

this.dynamicPropertiesStore.applyBlock(false);

}

this.dynamicPropertiesStore.applyBlock(true);

if (slot <= 0) {

logger.warn("missedBlocks [" + slot + "] is illegal");

}

logger.info("update head, num = {}", block.getNum());

this.dynamicPropertiesStore.saveLatestBlockHeaderHash(block.getBlockId().getByteString());

this.dynamicPropertiesStore.saveLatestBlockHeaderNumber(block.getNum());

this.dynamicPropertiesStore.saveLatestBlockHeaderTimestamp(block.getTimeStamp());

revokingStore.setMaxSize((int) (dynamicPropertiesStore.getLatestBlockHeaderNumber()

- dynamicPropertiesStore.getLatestSolidifiedBlockNum()

+ 1));

khaosDb.setMaxSize((int)

(dynamicPropertiesStore.getLatestBlockHeaderNumber()

- dynamicPropertiesStore.getLatestSolidifiedBlockNum()

+ 1));

}

/**

* Get the fork branch.

*/

public LinkedList<BlockId> getBlockChainHashesOnFork(final BlockId forkBlockHash)

throws NonCommonBlockException {

final Pair<LinkedList<KhaosBlock>, LinkedList<KhaosBlock>> branch =

this.khaosDb.getBranch(

getDynamicPropertiesStore().getLatestBlockHeaderHash(), forkBlockHash);

LinkedList<KhaosBlock> blockCapsules = branch.getValue();

if (blockCapsules.isEmpty()) {

logger.info("empty branch {}", forkBlockHash);

return Lists.newLinkedList();

}

LinkedList<BlockId> result = blockCapsules.stream()

.map(KhaosBlock::getBlk)

.map(BlockCapsule::getBlockId)

.collect(Collectors.toCollection(LinkedList::new));

result.add(blockCapsules.peekLast().getBlk().getParentBlockId());

return result;

}

/**

* judge id.

*

* @param blockHash blockHash

*/

public boolean containBlock(final Sha256Hash blockHash) {

try {

return this.khaosDb.containBlockInMiniStore(blockHash)

|| blockStore.get(blockHash.getBytes()) != null;

} catch (ItemNotFoundException e) {

return false;

} catch (BadItemException e) {

return false;

}

}

public boolean containBlockInMainChain(BlockId blockId) {

try {

return blockStore.get(blockId.getBytes()) != null;

} catch (ItemNotFoundException e) {

return false;

} catch (BadItemException e) {

return false;

}

}

public void setBlockReference(TransactionCapsule trans) {

byte[] headHash = getDynamicPropertiesStore().getLatestBlockHeaderHash().getBytes();

long headNum = getDynamicPropertiesStore().getLatestBlockHeaderNumber();

trans.setReference(headNum, headHash);

}

/**

* Get a BlockCapsule by id.

*/

public BlockCapsule getBlockById(final Sha256Hash hash)

throws BadItemException, ItemNotFoundException {

return this.khaosDb.containBlock(hash)

? this.khaosDb.getBlock(hash)

: blockStore.get(hash.getBytes());

}

/**

* judge has blocks.

*/

public boolean hasBlocks() {

return blockStore.iterator().hasNext() || this.khaosDb.hasData();