143 lines
5.4 KiB
Nim
143 lines
5.4 KiB
Nim
import ../db/[db_chain, state_db], eth_common, chronicles, ../vm_state, ../vm_types, ../transaction, ranges,
|
|
../vm/[computation, interpreter_dispatch, message], ../constants, stint, nimcrypto,
|
|
../vm_state_transactions, sugar, ../utils, eth_trie/db, ../tracer, ./executor, json,
|
|
eth_bloom, strutils
|
|
|
|
type
|
|
# these types need to eradicated
|
|
# once eth_bloom and eth_common sync'ed
|
|
Bloom = eth_common.BloomFilter
|
|
LogsBloom = eth_bloom.BloomFilter
|
|
|
|
func logsBloom(logs: openArray[Log]): LogsBloom =
|
|
for log in logs:
|
|
result.incl log.address
|
|
for topic in log.topics:
|
|
result.incl topic
|
|
|
|
func createBloom*(receipts: openArray[Receipt]): Bloom =
|
|
var bloom: LogsBloom
|
|
for receipt in receipts:
|
|
bloom.value = bloom.value or logsBloom(receipt.logs).value
|
|
result = bloom.value.toByteArrayBE
|
|
|
|
proc makeReceipt(vmState: BaseVMState, stateRoot: Hash256, cumulativeGasUsed: GasInt): Receipt =
|
|
# TODO: post byzantium fork use status instead of rootHash
|
|
# currently, vmState.rootHash vs stateDb.rootHash can be different
|
|
# need to wait #188 solved
|
|
#result.stateRootOrStatus = hashOrStatus(vmState.blockHeader.stateRoot)
|
|
result.stateRootOrStatus = hashOrStatus(stateRoot)
|
|
result.cumulativeGasUsed = cumulativeGasUsed
|
|
result.logs = vmState.getAndClearLogEntries()
|
|
result.bloom = logsBloom(result.logs).value.toByteArrayBE
|
|
|
|
type
|
|
Chain* = ref object of AbstractChainDB
|
|
db: BaseChainDB
|
|
|
|
proc newChain*(db: BaseChainDB): Chain =
|
|
result.new
|
|
result.db = db
|
|
|
|
method genesisHash*(c: Chain): KeccakHash =
|
|
c.db.getBlockHash(0.toBlockNumber)
|
|
|
|
method getBlockHeader*(c: Chain, b: HashOrNum, output: var BlockHeader): bool =
|
|
case b.isHash
|
|
of true:
|
|
c.db.getBlockHeader(b.hash, output)
|
|
else:
|
|
c.db.getBlockHeader(b.number, output)
|
|
|
|
method getBestBlockHeader*(c: Chain): BlockHeader =
|
|
c.db.getCanonicalHead()
|
|
|
|
method getSuccessorHeader*(c: Chain, h: BlockHeader, output: var BlockHeader): bool =
|
|
let n = h.blockNumber + 1
|
|
c.db.getBlockHeader(n, output)
|
|
|
|
method getBlockBody*(c: Chain, blockHash: KeccakHash): BlockBodyRef =
|
|
result = nil
|
|
|
|
method persistBlocks*(c: Chain, headers: openarray[BlockHeader], bodies: openarray[BlockBody]) =
|
|
# Run the VM here
|
|
assert(headers.len == bodies.len)
|
|
|
|
let blockReward = 5.u256 * pow(10.u256, 18) # 5 ETH
|
|
|
|
let transaction = c.db.db.beginTransaction()
|
|
defer: transaction.dispose()
|
|
|
|
debug "Persisting blocks", range = $headers[0].blockNumber & " - " & $headers[^1].blockNumber
|
|
for i in 0 ..< headers.len:
|
|
let head = c.db.getCanonicalHead()
|
|
assert(head.blockNumber == headers[i].blockNumber - 1)
|
|
var stateDb = newAccountStateDB(c.db.db, head.stateRoot, c.db.pruneTrie)
|
|
var receipts = newSeq[Receipt](bodies[i].transactions.len)
|
|
|
|
assert(bodies[i].transactions.calcTxRoot == headers[i].txRoot)
|
|
|
|
if headers[i].txRoot != BLANK_ROOT_HASH:
|
|
assert(head.blockNumber == headers[i].blockNumber - 1)
|
|
let vmState = newBaseVMState(head, c.db)
|
|
assert(bodies[i].transactions.len != 0)
|
|
var cumulativeGasUsed = GasInt(0)
|
|
|
|
if bodies[i].transactions.len != 0:
|
|
trace "Has transactions", blockNumber = headers[i].blockNumber, blockHash = headers[i].blockHash
|
|
|
|
for txIndex, tx in bodies[i].transactions:
|
|
var sender: EthAddress
|
|
if tx.getSender(sender):
|
|
let txFee = processTransaction(stateDb, tx, sender, vmState)
|
|
|
|
# perhaps this can be moved somewhere else
|
|
let gasUsed = (txFee div tx.gasPrice.u256).truncate(GasInt)
|
|
cumulativeGasUsed += gasUsed
|
|
|
|
# miner fee
|
|
stateDb.addBalance(headers[i].coinbase, txFee)
|
|
else:
|
|
assert(false, "Could not get sender")
|
|
receipts[txIndex] = makeReceipt(vmState, stateDb.rootHash, cumulativeGasUsed)
|
|
|
|
var mainReward = blockReward
|
|
if headers[i].ommersHash != EMPTY_UNCLE_HASH:
|
|
let h = c.db.persistUncles(bodies[i].uncles)
|
|
assert(h == headers[i].ommersHash)
|
|
for u in 0 ..< bodies[i].uncles.len:
|
|
var uncleReward = bodies[i].uncles[u].blockNumber + 8.u256
|
|
uncleReward -= headers[i].blockNumber
|
|
uncleReward = uncleReward * blockReward
|
|
uncleReward = uncleReward div 8.u256
|
|
stateDb.addBalance(bodies[i].uncles[u].coinbase, uncleReward)
|
|
mainReward += blockReward div 32.u256
|
|
|
|
# Reward beneficiary
|
|
stateDb.addBalance(headers[i].coinbase, mainReward)
|
|
|
|
if headers[i].stateRoot != stateDb.rootHash:
|
|
debug "Wrong state root in block", blockNumber = headers[i].blockNumber, expected = headers[i].stateRoot, actual = stateDb.rootHash, arrivedFrom = c.db.getCanonicalHead().stateRoot
|
|
let ttrace = traceTransaction(c.db, headers[i], bodies[i], bodies[i].transactions.len - 1, {})
|
|
trace "NIMBUS TRACE", transactionTrace=ttrace.pretty()
|
|
|
|
assert(headers[i].stateRoot == stateDb.rootHash)
|
|
|
|
let bloom = createBloom(receipts)
|
|
if headers[i].bloom != bloom:
|
|
debug "wrong bloom in block", blockNumber = headers[i].blockNumber
|
|
assert(headers[i].bloom == bloom)
|
|
|
|
let receiptRoot = calcReceiptRoot(receipts)
|
|
if headers[i].receiptRoot != receiptRoot:
|
|
debug "wrong receipt in block", blockNumber = headers[i].blockNumber, receiptRoot, valid=headers[i].receiptRoot
|
|
assert(headers[i].receiptRoot == receiptRoot)
|
|
|
|
discard c.db.persistHeaderToDb(headers[i])
|
|
assert(c.db.getCanonicalHead().blockHash == headers[i].blockHash)
|
|
|
|
c.db.persistTransactions(headers[i].blockNumber, bodies[i].transactions)
|
|
c.db.persistReceipts(receipts)
|
|
|
|
transaction.commit()
|