private OperatingError _Execute(
Block block,
IEnumerable <TransactionReceipt> transactions,
out List <TransactionReceipt> removeTransactions,
out List <TransactionReceipt> relayTransactions,
bool isEmulation,
out ulong gasUsed,
out Money totalFee
)
{
var mode = isEmulation ? "emulate" : "commit";
using var timer = BlockExecTime.WithLabels(mode).NewTimer();
BlockExecCounter.WithLabels(mode).Inc();
totalFee = Money.Zero;
gasUsed = 0;
_contractTxJustExecuted = null;
var currentTransactions = transactions
.ToDictionary(tx => tx.Hash, tx => tx);
removeTransactions = new List <TransactionReceipt>();
relayTransactions = new List <TransactionReceipt>();
/* verify next block */
var error = Verify(block);
if (error != OperatingError.Ok)
{
return(error);
}
/* check next block index */
var currentBlockHeader = _stateManager.LastApprovedSnapshot.Blocks.GetTotalBlockHeight();
if (!_IsGenesisBlock(block) && currentBlockHeader + 1 != block.Header.Index)
{
Logger.LogError($"Error executing block {block.Header.Index}: latest block is {currentBlockHeader}");
return(OperatingError.InvalidNonce);
}
var exists = _stateManager.LastApprovedSnapshot.Blocks.GetBlockByHeight(block.Header.Index);
if (exists != null)
{
return(OperatingError.BlockAlreadyExists);
}
/* check prev block hash */
var latestBlock = _stateManager.LastApprovedSnapshot.Blocks.GetBlockByHeight(currentBlockHeader);
if (latestBlock != null && !block.Header.PrevBlockHash.Equals(latestBlock.Hash))
{
return(OperatingError.PrevBlockHashMismatched);
}
/* verify block signatures */
error = VerifySignatures(block, false);
if (error != OperatingError.Ok)
{
return(error);
}
/* check do we have all transactions specified */
if (block.TransactionHashes.Any(txHash => !currentTransactions.ContainsKey(txHash)))
{
return(OperatingError.TransactionLost);
}
/* execute transactions */
ulong indexInBlock = 0;
foreach (var txHash in block.TransactionHashes)
{
Logger.LogTrace($"Trying to execute tx : {txHash.ToHex()}");
/* try to find transaction by hash */
var receipt = currentTransactions[txHash];
if (receipt is null)
{
Logger.LogError($"For tx : {txHash.ToHex()} receipt is NULL");
}
receipt.Block = block.Header.Index;
receipt.GasUsed = GasMetering.DefaultTxCost;
receipt.IndexInBlock = indexInBlock;
var transaction = receipt.Transaction;
Logger.LogInformation($"tx : {txHash.ToHex()} blockHeaderIndex:{receipt.Block} indexinBlock:{receipt.IndexInBlock}");
try
{
// to make any changes to the state, it's required to
// (1) create a new snapshot, (2) make changes to the snapshot
// (3) either approve or rollback()
// approving adds all the changes to the lastApprovedSnapshot
// and rollback() discards all the changes and lastApprovedSnapshot is not changed
var snapshot = _stateManager.NewSnapshot();
// if the "from" address of the transaction does not have enough gas to
// pay for the transaction, then this transaction is not executed and thus skipped.
var gasLimitCheck = _CheckTransactionGasLimit(transaction, snapshot);
if (gasLimitCheck != OperatingError.Ok)
{
removeTransactions.Add(receipt);
_stateManager.Rollback();
Logger.LogWarning(
$"Unable to execute transaction {txHash.ToHex()} with nonce ({transaction.Nonce}): not enough balance for gas"
);
continue;
}
else
{
Logger.LogInformation($"Gas limit is ok for tx : {txHash.ToHex()}");
}
/* try to execute transaction */
OperatingError result = OperatingError.Ok;
try
{
result = _transactionManager.Execute(block, receipt, snapshot);
}
catch (Exception e)
{
Logger.LogWarning($"Exception during tx execution: {e}");
result = OperatingError.InvalidContract;
}
var txFailed = result != OperatingError.Ok;
if (txFailed)
{
_stateManager.Rollback();
// what exactly is nonce of an transaction ?
// nonce represents the label of the transactions from a particular address
// for example - let's say address A has 3 transactions in the chain.
// their nonces must be 0, 1, 2
// if A sends a new transaction, it's nonce must be 3.
// if the nonce does not match with the expected nonce, this transaction
// is also removed and skipped
if (result == OperatingError.InvalidNonce)
{
removeTransactions.Add(receipt);
Logger.LogWarning(
$"Unable to execute transaction {txHash.ToHex()} with nonce ({transaction.Nonce}): invalid nonce"
);
continue;
}
snapshot = _stateManager.NewSnapshot();
// Adds this transaction to the Transactions Snapshot
snapshot.Transactions.AddTransaction(receipt, TransactionStatus.Failed);
Logger.LogTrace($"Transaction {txHash.ToHex()} failed because of error: {result}");
}
else
{
Logger.LogInformation($"Tx is not failed for tx : {txHash.ToHex()}");
}
/* check block gas limit after execution */
gasUsed += receipt.GasUsed;
if (gasUsed > GasMetering.DefaultBlockGasLimit)
{
removeTransactions.Add(receipt);
relayTransactions.Add(receipt);
_stateManager.Rollback();
/* this should never happen cuz that mean that someone applied overflowed block */
if (!isEmulation)
{
throw new InvalidBlockException(OperatingError.BlockGasOverflow);
}
Logger.LogWarning(
$"Unable to take transaction {txHash.ToHex()} with gas {receipt.GasUsed}, block gas limit overflowed {gasUsed}/{GasMetering.DefaultBlockGasLimit}");
continue;
}
else
{
Logger.LogInformation($"Block gas limit after execution ok for tx : {txHash.ToHex()}");
}
/* try to take fee from sender */
result = _TakeTransactionFee(receipt, snapshot, out var fee);
if (result != OperatingError.Ok)
{
removeTransactions.Add(receipt);
_stateManager.Rollback();
Logger.LogWarning(
$"Unable to execute transaction {txHash.ToHex()} with nonce ({transaction.Nonce}), cannot take fee due to {result}"
);
continue;
}
else
{
Logger.LogInformation($"Fee taken for tx : {txHash.ToHex()}");
}
totalFee += fee;
if (!txFailed)
{
/* mark transaction as executed */
Logger.LogTrace($"Transaction executed {txHash.ToHex()}");
snapshot.Transactions.AddTransaction(receipt, TransactionStatus.Executed);
}
_stateManager.Approve();
indexInBlock++;
}
catch (Exception ex)
{
Logger.LogWarning($"Exception [{ex}] while executing tx {txHash.ToHex()}");
removeTransactions.Add(receipt);
if (_stateManager.PendingSnapshot != null)
{
_stateManager.Rollback();
}
}
if (_contractTxJustExecuted != null && !isEmulation)
{
try
{
// this invocation is required to trigger key generation appropriately
OnSystemContractInvoked?.Invoke(this, _contractTxJustExecuted);
}
catch (Exception e)
{
Logger.LogError(
$"While executing block {block.Header.Index} exception occured while processing system contract call: {e}");
}
finally
{
_contractTxJustExecuted = null;
_localTransactionRepository.TryAddTransaction(receipt);
}
}
}
block.GasPrice = _CalcEstimatedBlockFee(currentTransactions.Values);
/* save block to repository */
try
{
var snapshotBlock = _stateManager.NewSnapshot();
snapshotBlock.Blocks.AddBlock(block);
_stateManager.Approve();
}
catch (Exception ex)
{
Logger.LogWarning($"Exception [{ex.ToString()}] while adding block tx");
if (_stateManager.PendingSnapshot != null)
{
_stateManager.Rollback();
}
}
return(OperatingError.Ok);
}
public InvalidTransactionException(OperatingError operatingError)
{
OperatingError = operatingError;
}
public InvalidBlockException(OperatingError operatingError)
{
OperatingError = operatingError;
}
