+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/core/rawdb"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/vm"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/core/types"

+// Copyright 2017 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+// Package bloombits implements bloom filtering on batches of data.

+package bloombits

+// Copyright 2017 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package bloombits

+

+import (

+ "errors"

+

+ "github.com/ava-labs/coreth/core/types"

+)

+

+var (

+ // errSectionOutOfBounds is returned if the user tried to add more bloom filters

+ // to the batch than available space, or if tries to retrieve above the capacity.

+ errSectionOutOfBounds = errors.New("section out of bounds")

+

+ // errBloomBitOutOfBounds is returned if the user tried to retrieve specified

+ // bit bloom above the capacity.

+ errBloomBitOutOfBounds = errors.New("bloom bit out of bounds")

+)

+

+// Generator takes a number of bloom filters and generates the rotated bloom bits

+// to be used for batched filtering.

+type Generator struct {

+ blooms [types.BloomBitLength][]byte // Rotated blooms for per-bit matching

+ sections uint // Number of sections to batch together

+ nextSec uint // Next section to set when adding a bloom

+}

+

+// NewGenerator creates a rotated bloom generator that can iteratively fill a

+// batched bloom filter's bits.

+func NewGenerator(sections uint) (*Generator, error) {

+ if sections%8 != 0 {

+ return nil, errors.New("section count not multiple of 8")

+ }

+ b := &Generator{sections: sections}

+ for i := 0; i < types.BloomBitLength; i++ {

+ b.blooms[i] = make([]byte, sections/8)

+ }

+ return b, nil

+}

+

+// AddBloom takes a single bloom filter and sets the corresponding bit column

+// in memory accordingly.

+func (b *Generator) AddBloom(index uint, bloom types.Bloom) error {

+ // Make sure we're not adding more bloom filters than our capacity

+ if b.nextSec >= b.sections {

+ return errSectionOutOfBounds

+ }

+ if b.nextSec != index {

+ return errors.New("bloom filter with unexpected index")

+ }

+ // Rotate the bloom and insert into our collection

+ byteIndex := b.nextSec / 8

+ bitMask := byte(1) << byte(7-b.nextSec%8)

+

+ for i := 0; i < types.BloomBitLength; i++ {

+ bloomByteIndex := types.BloomByteLength - 1 - i/8

+ bloomBitMask := byte(1) << byte(i%8)

+

+ if (bloom[bloomByteIndex] & bloomBitMask) != 0 {

+ b.blooms[i][byteIndex] |= bitMask

+ }

+ }

+ b.nextSec++

+

+ return nil

+}

+

+// Bitset returns the bit vector belonging to the given bit index after all

+// blooms have been added.

+func (b *Generator) Bitset(idx uint) ([]byte, error) {

+ if b.nextSec != b.sections {

+ return nil, errors.New("bloom not fully generated yet")

+ }

+ if idx >= types.BloomBitLength {

+ return nil, errBloomBitOutOfBounds

+ }

+ return b.blooms[idx], nil

+}

+// Copyright 2017 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package bloombits

+

+import (

+ "bytes"

+ "context"

+ "errors"

+ "math"

+ "sort"

+ "sync"

+ "sync/atomic"

+ "time"

+

+ "github.com/ava-labs/go-ethereum/common/bitutil"

+ "github.com/ava-labs/go-ethereum/crypto"

+)

+

+// bloomIndexes represents the bit indexes inside the bloom filter that belong

+// to some key.

+type bloomIndexes [3]uint

+

+// calcBloomIndexes returns the bloom filter bit indexes belonging to the given key.

+func calcBloomIndexes(b []byte) bloomIndexes {

+ b = crypto.Keccak256(b)

+

+ var idxs bloomIndexes

+ for i := 0; i < len(idxs); i++ {

+ idxs[i] = (uint(b[2*i])<<8)&2047 + uint(b[2*i+1])

+ }

+ return idxs

+}

+

+// partialMatches with a non-nil vector represents a section in which some sub-

+// matchers have already found potential matches. Subsequent sub-matchers will

+// binary AND their matches with this vector. If vector is nil, it represents a

+// section to be processed by the first sub-matcher.

+type partialMatches struct {

+ section uint64

+ bitset []byte

+}

+

+// Retrieval represents a request for retrieval task assignments for a given

+// bit with the given number of fetch elements, or a response for such a request.

+// It can also have the actual results set to be used as a delivery data struct.

+//

+// The contest and error fields are used by the light client to terminate matching

+// early if an error is encountered on some path of the pipeline.

+type Retrieval struct {

+ Bit uint

+ Sections []uint64

+ Bitsets [][]byte

+

+ Context context.Context

+ Error error

+}

+

+// Matcher is a pipelined system of schedulers and logic matchers which perform

+// binary AND/OR operations on the bit-streams, creating a stream of potential

+// blocks to inspect for data content.

+type Matcher struct {

+ sectionSize uint64 // Size of the data batches to filter on

+

+ filters [][]bloomIndexes // Filter the system is matching for

+ schedulers map[uint]*scheduler // Retrieval schedulers for loading bloom bits

+

+ retrievers chan chan uint // Retriever processes waiting for bit allocations

+ counters chan chan uint // Retriever processes waiting for task count reports

+ retrievals chan chan *Retrieval // Retriever processes waiting for task allocations

+ deliveries chan *Retrieval // Retriever processes waiting for task response deliveries

+

+ running uint32 // Atomic flag whether a session is live or not

+}

+

+// NewMatcher creates a new pipeline for retrieving bloom bit streams and doing

+// address and topic filtering on them. Setting a filter component to `nil` is

+// allowed and will result in that filter rule being skipped (OR 0x11...1).

+func NewMatcher(sectionSize uint64, filters [][][]byte) *Matcher {

+ // Create the matcher instance

+ m := &Matcher{

+ sectionSize: sectionSize,

+ schedulers: make(map[uint]*scheduler),

+ retrievers: make(chan chan uint),

+ counters: make(chan chan uint),

+ retrievals: make(chan chan *Retrieval),

+ deliveries: make(chan *Retrieval),

+ }

+ // Calculate the bloom bit indexes for the groups we're interested in

+ m.filters = nil

+

+ for _, filter := range filters {

+ // Gather the bit indexes of the filter rule, special casing the nil filter

+ if len(filter) == 0 {

+ continue

+ }

+ bloomBits := make([]bloomIndexes, len(filter))

+ for i, clause := range filter {

+ if clause == nil {

+ bloomBits = nil

+ break

+ }

+ bloomBits[i] = calcBloomIndexes(clause)

+ }

+ // Accumulate the filter rules if no nil rule was within

+ if bloomBits != nil {

+ m.filters = append(m.filters, bloomBits)

+ }

+ }

+ // For every bit, create a scheduler to load/download the bit vectors

+ for _, bloomIndexLists := range m.filters {

+ for _, bloomIndexList := range bloomIndexLists {

+ for _, bloomIndex := range bloomIndexList {

+ m.addScheduler(bloomIndex)

+ }

+ }

+ }

+ return m

+}

+

+// addScheduler adds a bit stream retrieval scheduler for the given bit index if

+// it has not existed before. If the bit is already selected for filtering, the

+// existing scheduler can be used.

+func (m *Matcher) addScheduler(idx uint) {

+ if _, ok := m.schedulers[idx]; ok {

+ return

+ }

+ m.schedulers[idx] = newScheduler(idx)

+}

+

+// Start starts the matching process and returns a stream of bloom matches in

+// a given range of blocks. If there are no more matches in the range, the result

+// channel is closed.

+func (m *Matcher) Start(ctx context.Context, begin, end uint64, results chan uint64) (*MatcherSession, error) {

+ // Make sure we're not creating concurrent sessions

+ if atomic.SwapUint32(&m.running, 1) == 1 {

+ return nil, errors.New("matcher already running")

+ }

+ defer atomic.StoreUint32(&m.running, 0)

+

+ // Initiate a new matching round

+ session := &MatcherSession{

+ matcher: m,

+ quit: make(chan struct{}),

+ kill: make(chan struct{}),

+ ctx: ctx,

+ }

+ for _, scheduler := range m.schedulers {

+ scheduler.reset()

+ }

+ sink := m.run(begin, end, cap(results), session)

+

+ // Read the output from the result sink and deliver to the user

+ session.pend.Add(1)

+ go func() {

+ defer session.pend.Done()

+ defer close(results)

+

+ for {

+ select {

+ case <-session.quit:

+ return

+

+ case res, ok := <-sink:

+ // New match result found

+ if !ok {

+ return

+ }

+ // Calculate the first and last blocks of the section

+ sectionStart := res.section * m.sectionSize

+

+ first := sectionStart

+ if begin > first {

+ first = begin

+ }

+ last := sectionStart + m.sectionSize - 1

+ if end < last {

+ last = end

+ }

+ // Iterate over all the blocks in the section and return the matching ones

+ for i := first; i <= last; i++ {

+ // Skip the entire byte if no matches are found inside (and we're processing an entire byte!)

+ next := res.bitset[(i-sectionStart)/8]

+ if next == 0 {

+ if i%8 == 0 {

+ i += 7

+ }

+ continue

+ }

+ // Some bit it set, do the actual submatching

+ if bit := 7 - i%8; next&(1<<bit) != 0 {

+ select {

+ case <-session.quit:

+ return

+ case results <- i:

+ }

+ }

+ }

+ }

+ }

+ }()

+ return session, nil

+}

+

+// run creates a daisy-chain of sub-matchers, one for the address set and one

+// for each topic set, each sub-matcher receiving a section only if the previous

+// ones have all found a potential match in one of the blocks of the section,

+// then binary AND-ing its own matches and forwarding the result to the next one.

+//

+// The method starts feeding the section indexes into the first sub-matcher on a

+// new goroutine and returns a sink channel receiving the results.

+func (m *Matcher) run(begin, end uint64, buffer int, session *MatcherSession) chan *partialMatches {

+ // Create the source channel and feed section indexes into

+ source := make(chan *partialMatches, buffer)

+

+ session.pend.Add(1)

+ go func() {

+ defer session.pend.Done()

+ defer close(source)

+

+ for i := begin / m.sectionSize; i <= end/m.sectionSize; i++ {

+ select {

+ case <-session.quit:

+ return

+ case source <- &partialMatches{i, bytes.Repeat([]byte{0xff}, int(m.sectionSize/8))}:

+ }

+ }

+ }()

+ // Assemble the daisy-chained filtering pipeline

+ next := source

+ dist := make(chan *request, buffer)

+

+ for _, bloom := range m.filters {

+ next = m.subMatch(next, dist, bloom, session)

+ }

+ // Start the request distribution

+ session.pend.Add(1)

+ go m.distributor(dist, session)

+

+ return next

+}

+

+// subMatch creates a sub-matcher that filters for a set of addresses or topics, binary OR-s those matches, then

+// binary AND-s the result to the daisy-chain input (source) and forwards it to the daisy-chain output.

+// The matches of each address/topic are calculated by fetching the given sections of the three bloom bit indexes belonging to

+// that address/topic, and binary AND-ing those vectors together.

+func (m *Matcher) subMatch(source chan *partialMatches, dist chan *request, bloom []bloomIndexes, session *MatcherSession) chan *partialMatches {

+ // Start the concurrent schedulers for each bit required by the bloom filter

+ sectionSources := make([][3]chan uint64, len(bloom))

+ sectionSinks := make([][3]chan []byte, len(bloom))

+ for i, bits := range bloom {

+ for j, bit := range bits {

+ sectionSources[i][j] = make(chan uint64, cap(source))

+ sectionSinks[i][j] = make(chan []byte, cap(source))

+

+ m.schedulers[bit].run(sectionSources[i][j], dist, sectionSinks[i][j], session.quit, &session.pend)

+ }

+ }

+

+ process := make(chan *partialMatches, cap(source)) // entries from source are forwarded here after fetches have been initiated

+ results := make(chan *partialMatches, cap(source))

+

+ session.pend.Add(2)

+ go func() {

+ // Tear down the goroutine and terminate all source channels

+ defer session.pend.Done()

+ defer close(process)

+

+ defer func() {

+ for _, bloomSources := range sectionSources {

+ for _, bitSource := range bloomSources {

+ close(bitSource)

+ }

+ }

+ }()

+ // Read sections from the source channel and multiplex into all bit-schedulers

+ for {

+ select {

+ case <-session.quit:

+ return

+

+ case subres, ok := <-source:

+ // New subresult from previous link

+ if !ok {

+ return

+ }

+ // Multiplex the section index to all bit-schedulers

+ for _, bloomSources := range sectionSources {

+ for _, bitSource := range bloomSources {

+ select {

+ case <-session.quit:

+ return

+ case bitSource <- subres.section:

+ }

+ }

+ }

+ // Notify the processor that this section will become available

+ select {

+ case <-session.quit:

+ return

+ case process <- subres:

+ }

+ }

+ }

+ }()

+

+ go func() {

+ // Tear down the goroutine and terminate the final sink channel

+ defer session.pend.Done()

+ defer close(results)

+

+ // Read the source notifications and collect the delivered results

+ for {

+ select {

+ case <-session.quit:

+ return

+

+ case subres, ok := <-process:

+ // Notified of a section being retrieved

+ if !ok {

+ return

+ }

+ // Gather all the sub-results and merge them together

+ var orVector []byte

+ for _, bloomSinks := range sectionSinks {

+ var andVector []byte

+ for _, bitSink := range bloomSinks {

+ var data []byte

+ select {

+ case <-session.quit:

+ return

+ case data = <-bitSink:

+ }

+ if andVector == nil {

+ andVector = make([]byte, int(m.sectionSize/8))

+ copy(andVector, data)

+ } else {

+ bitutil.ANDBytes(andVector, andVector, data)

+ }

+ }

+ if orVector == nil {

+ orVector = andVector

+ } else {

+ bitutil.ORBytes(orVector, orVector, andVector)

+ }

+ }

+

+ if orVector == nil {

+ orVector = make([]byte, int(m.sectionSize/8))

+ }

+ if subres.bitset != nil {

+ bitutil.ANDBytes(orVector, orVector, subres.bitset)

+ }

+ if bitutil.TestBytes(orVector) {

+ select {

+ case <-session.quit:

+ return

+ case results <- &partialMatches{subres.section, orVector}:

+ }

+ }

+ }

+ }

+ }()

+ return results

+}

+

+// distributor receives requests from the schedulers and queues them into a set

+// of pending requests, which are assigned to retrievers wanting to fulfil them.

+func (m *Matcher) distributor(dist chan *request, session *MatcherSession) {

+ defer session.pend.Done()

+

+ var (

+ requests = make(map[uint][]uint64) // Per-bit list of section requests, ordered by section number

+ unallocs = make(map[uint]struct{}) // Bits with pending requests but not allocated to any retriever

+ retrievers chan chan uint // Waiting retrievers (toggled to nil if unallocs is empty)

+ )

+ var (

+ allocs int // Number of active allocations to handle graceful shutdown requests

+ shutdown = session.quit // Shutdown request channel, will gracefully wait for pending requests

+ )

+

+ // assign is a helper method fo try to assign a pending bit an actively

+ // listening servicer, or schedule it up for later when one arrives.

+ assign := func(bit uint) {

+ select {

+ case fetcher := <-m.retrievers:

+ allocs++

+ fetcher <- bit

+ default:

+ // No retrievers active, start listening for new ones

+ retrievers = m.retrievers

+ unallocs[bit] = struct{}{}

+ }

+ }

+

+ for {

+ select {

+ case <-shutdown:

+ // Graceful shutdown requested, wait until all pending requests are honoured

+ if allocs == 0 {

+ return

+ }

+ shutdown = nil

+

+ case <-session.kill:

+ // Pending requests not honoured in time, hard terminate

+ return

+

+ case req := <-dist:

+ // New retrieval request arrived to be distributed to some fetcher process

+ queue := requests[req.bit]

+ index := sort.Search(len(queue), func(i int) bool { return queue[i] >= req.section })

+ requests[req.bit] = append(queue[:index], append([]uint64{req.section}, queue[index:]...)...)

+

+ // If it's a new bit and we have waiting fetchers, allocate to them

+ if len(queue) == 0 {

+ assign(req.bit)

+ }

+

+ case fetcher := <-retrievers:

+ // New retriever arrived, find the lowest section-ed bit to assign

+ bit, best := uint(0), uint64(math.MaxUint64)

+ for idx := range unallocs {

+ if requests[idx][0] < best {

+ bit, best = idx, requests[idx][0]

+ }

+ }

+ // Stop tracking this bit (and alloc notifications if no more work is available)

+ delete(unallocs, bit)

+ if len(unallocs) == 0 {

+ retrievers = nil

+ }

+ allocs++

+ fetcher <- bit

+

+ case fetcher := <-m.counters:

+ // New task count request arrives, return number of items

+ fetcher <- uint(len(requests[<-fetcher]))

+

+ case fetcher := <-m.retrievals:

+ // New fetcher waiting for tasks to retrieve, assign

+ task := <-fetcher

+ if want := len(task.Sections); want >= len(requests[task.Bit]) {

+ task.Sections = requests[task.Bit]

+ delete(requests, task.Bit)

+ } else {

+ task.Sections = append(task.Sections[:0], requests[task.Bit][:want]...)

+ requests[task.Bit] = append(requests[task.Bit][:0], requests[task.Bit][want:]...)

+ }

+ fetcher <- task

+

+ // If anything was left unallocated, try to assign to someone else

+ if len(requests[task.Bit]) > 0 {

+ assign(task.Bit)

+ }

+

+ case result := <-m.deliveries:

+ // New retrieval task response from fetcher, split out missing sections and

+ // deliver complete ones

+ var (

+ sections = make([]uint64, 0, len(result.Sections))

+ bitsets = make([][]byte, 0, len(result.Bitsets))

+ missing = make([]uint64, 0, len(result.Sections))

+ )

+ for i, bitset := range result.Bitsets {

+ if len(bitset) == 0 {

+ missing = append(missing, result.Sections[i])

+ continue

+ }

+ sections = append(sections, result.Sections[i])

+ bitsets = append(bitsets, bitset)

+ }

+ m.schedulers[result.Bit].deliver(sections, bitsets)

+ allocs--

+

+ // Reschedule missing sections and allocate bit if newly available

+ if len(missing) > 0 {

+ queue := requests[result.Bit]

+ for _, section := range missing {

+ index := sort.Search(len(queue), func(i int) bool { return queue[i] >= section })

+ queue = append(queue[:index], append([]uint64{section}, queue[index:]...)...)

+ }

+ requests[result.Bit] = queue

+

+ if len(queue) == len(missing) {

+ assign(result.Bit)

+ }

+ }

+ // If we're in the process of shutting down, terminate

+ if allocs == 0 && shutdown == nil {

+ return

+ }

+ }

+ }

+}

+

+// MatcherSession is returned by a started matcher to be used as a terminator

+// for the actively running matching operation.

+type MatcherSession struct {

+ matcher *Matcher

+

+ closer sync.Once // Sync object to ensure we only ever close once

+ quit chan struct{} // Quit channel to request pipeline termination

+ kill chan struct{} // Term channel to signal non-graceful forced shutdown

+

+ ctx context.Context // Context used by the light client to abort filtering

+ err atomic.Value // Global error to track retrieval failures deep in the chain

+

+ pend sync.WaitGroup

+}

+

+// Close stops the matching process and waits for all subprocesses to terminate

+// before returning. The timeout may be used for graceful shutdown, allowing the

+// currently running retrievals to complete before this time.

+func (s *MatcherSession) Close() {

+ s.closer.Do(func() {

+ // Signal termination and wait for all goroutines to tear down

+ close(s.quit)

+ time.AfterFunc(time.Second, func() { close(s.kill) })

+ s.pend.Wait()

+ })

+}

+

+// Error returns any failure encountered during the matching session.

+func (s *MatcherSession) Error() error {

+ if err := s.err.Load(); err != nil {

+ return err.(error)

+ }

+ return nil

+}

+

+// AllocateRetrieval assigns a bloom bit index to a client process that can either

+// immediately request and fetch the section contents assigned to this bit or wait

+// a little while for more sections to be requested.

+func (s *MatcherSession) AllocateRetrieval() (uint, bool) {

+ fetcher := make(chan uint)

+

+ select {

+ case <-s.quit:

+ return 0, false

+ case s.matcher.retrievers <- fetcher:

+ bit, ok := <-fetcher

+ return bit, ok

+ }

+}

+

+// PendingSections returns the number of pending section retrievals belonging to

+// the given bloom bit index.

+func (s *MatcherSession) PendingSections(bit uint) int {

+ fetcher := make(chan uint)

+

+ select {

+ case <-s.quit:

+ return 0

+ case s.matcher.counters <- fetcher:

+ fetcher <- bit

+ return int(<-fetcher)

+ }

+}

+

+// AllocateSections assigns all or part of an already allocated bit-task queue

+// to the requesting process.

+func (s *MatcherSession) AllocateSections(bit uint, count int) []uint64 {

+ fetcher := make(chan *Retrieval)

+

+ select {

+ case <-s.quit:

+ return nil

+ case s.matcher.retrievals <- fetcher:

+ task := &Retrieval{

+ Bit: bit,

+ Sections: make([]uint64, count),

+ }

+ fetcher <- task

+ return (<-fetcher).Sections

+ }

+}

+

+// DeliverSections delivers a batch of section bit-vectors for a specific bloom

+// bit index to be injected into the processing pipeline.

+func (s *MatcherSession) DeliverSections(bit uint, sections []uint64, bitsets [][]byte) {

+ select {

+ case <-s.kill:

+ return

+ case s.matcher.deliveries <- &Retrieval{Bit: bit, Sections: sections, Bitsets: bitsets}:

+ }

+}

+

+// Multiplex polls the matcher session for retrieval tasks and multiplexes it into

+// the requested retrieval queue to be serviced together with other sessions.

+//

+// This method will block for the lifetime of the session. Even after termination

+// of the session, any request in-flight need to be responded to! Empty responses

+// are fine though in that case.

+func (s *MatcherSession) Multiplex(batch int, wait time.Duration, mux chan chan *Retrieval) {

+ for {

+ // Allocate a new bloom bit index to retrieve data for, stopping when done

+ bit, ok := s.AllocateRetrieval()

+ if !ok {

+ return

+ }

+ // Bit allocated, throttle a bit if we're below our batch limit

+ if s.PendingSections(bit) < batch {

+ select {

+ case <-s.quit:

+ // Session terminating, we can't meaningfully service, abort

+ s.AllocateSections(bit, 0)

+ s.DeliverSections(bit, []uint64{}, [][]byte{})

+ return

+

+ case <-time.After(wait):

+ // Throttling up, fetch whatever's available

+ }

+ }

+ // Allocate as much as we can handle and request servicing

+ sections := s.AllocateSections(bit, batch)

+ request := make(chan *Retrieval)

+

+ select {

+ case <-s.quit:

+ // Session terminating, we can't meaningfully service, abort

+ s.DeliverSections(bit, sections, make([][]byte, len(sections)))

+ return

+

+ case mux <- request:

+ // Retrieval accepted, something must arrive before we're aborting

+ request <- &Retrieval{Bit: bit, Sections: sections, Context: s.ctx}

+

+ result := <-request

+ if result.Error != nil {

+ s.err.Store(result.Error)

+ s.Close()

+ }

+ s.DeliverSections(result.Bit, result.Sections, result.Bitsets)

+ }

+ }

+}

+// Copyright 2017 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package bloombits

+

+import (

+ "sync"

+)

+

+// request represents a bloom retrieval task to prioritize and pull from the local

+// database or remotely from the network.

+type request struct {

+ section uint64 // Section index to retrieve the a bit-vector from

+ bit uint // Bit index within the section to retrieve the vector of

+}

+

+// response represents the state of a requested bit-vector through a scheduler.

+type response struct {

+ cached []byte // Cached bits to dedup multiple requests

+ done chan struct{} // Channel to allow waiting for completion

+}

+

+// scheduler handles the scheduling of bloom-filter retrieval operations for

+// entire section-batches belonging to a single bloom bit. Beside scheduling the

+// retrieval operations, this struct also deduplicates the requests and caches

+// the results to minimize network/database overhead even in complex filtering

+// scenarios.

+type scheduler struct {

+ bit uint // Index of the bit in the bloom filter this scheduler is responsible for

+ responses map[uint64]*response // Currently pending retrieval requests or already cached responses

+ lock sync.Mutex // Lock protecting the responses from concurrent access

+}

+

+// newScheduler creates a new bloom-filter retrieval scheduler for a specific

+// bit index.

+func newScheduler(idx uint) *scheduler {

+ return &scheduler{

+ bit: idx,

+ responses: make(map[uint64]*response),

+ }

+}

+

+// run creates a retrieval pipeline, receiving section indexes from sections and

+// returning the results in the same order through the done channel. Concurrent

+// runs of the same scheduler are allowed, leading to retrieval task deduplication.

+func (s *scheduler) run(sections chan uint64, dist chan *request, done chan []byte, quit chan struct{}, wg *sync.WaitGroup) {

+ // Create a forwarder channel between requests and responses of the same size as

+ // the distribution channel (since that will block the pipeline anyway).

+ pend := make(chan uint64, cap(dist))

+

+ // Start the pipeline schedulers to forward between user -> distributor -> user

+ wg.Add(2)

+ go s.scheduleRequests(sections, dist, pend, quit, wg)

+ go s.scheduleDeliveries(pend, done, quit, wg)

+}

+

+// reset cleans up any leftovers from previous runs. This is required before a

+// restart to ensure the no previously requested but never delivered state will

+// cause a lockup.

+func (s *scheduler) reset() {

+ s.lock.Lock()

+ defer s.lock.Unlock()

+

+ for section, res := range s.responses {

+ if res.cached == nil {

+ delete(s.responses, section)

+ }

+ }

+}

+

+// scheduleRequests reads section retrieval requests from the input channel,

+// deduplicates the stream and pushes unique retrieval tasks into the distribution

+// channel for a database or network layer to honour.

+func (s *scheduler) scheduleRequests(reqs chan uint64, dist chan *request, pend chan uint64, quit chan struct{}, wg *sync.WaitGroup) {

+ // Clean up the goroutine and pipeline when done

+ defer wg.Done()

+ defer close(pend)

+

+ // Keep reading and scheduling section requests

+ for {

+ select {

+ case <-quit:

+ return

+

+ case section, ok := <-reqs:

+ // New section retrieval requested

+ if !ok {

+ return

+ }

+ // Deduplicate retrieval requests

+ unique := false

+

+ s.lock.Lock()

+ if s.responses[section] == nil {

+ s.responses[section] = &response{

+ done: make(chan struct{}),

+ }

+ unique = true

+ }

+ s.lock.Unlock()

+

+ // Schedule the section for retrieval and notify the deliverer to expect this section

+ if unique {

+ select {

+ case <-quit:

+ return

+ case dist <- &request{bit: s.bit, section: section}:

+ }

+ }

+ select {

+ case <-quit:

+ return

+ case pend <- section:

+ }

+ }

+ }

+}

+

+// scheduleDeliveries reads section acceptance notifications and waits for them

+// to be delivered, pushing them into the output data buffer.

+func (s *scheduler) scheduleDeliveries(pend chan uint64, done chan []byte, quit chan struct{}, wg *sync.WaitGroup) {

+ // Clean up the goroutine and pipeline when done

+ defer wg.Done()

+ defer close(done)

+

+ // Keep reading notifications and scheduling deliveries

+ for {

+ select {

+ case <-quit:

+ return

+

+ case idx, ok := <-pend:

+ // New section retrieval pending

+ if !ok {

+ return

+ }

+ // Wait until the request is honoured

+ s.lock.Lock()

+ res := s.responses[idx]

+ s.lock.Unlock()

+

+ select {

+ case <-quit:

+ return

+ case <-res.done:

+ }

+ // Deliver the result

+ select {

+ case <-quit:

+ return

+ case done <- res.cached:

+ }

+ }

+ }

+}

+

+// deliver is called by the request distributor when a reply to a request arrives.

+func (s *scheduler) deliver(sections []uint64, data [][]byte) {

+ s.lock.Lock()

+ defer s.lock.Unlock()

+

+ for i, section := range sections {

+ if res := s.responses[section]; res != nil && res.cached == nil { // Avoid non-requests and double deliveries

+ res.cached = data[i]

+ close(res.done)

+ }

+ }

+}

+ "github.com/ava-labs/coreth/core/rawdb"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/vm"

+ "github.com/ava-labs/go-ethereum/log"

+ CanTransfer: CanTransfer,

+ CanTransferMC: CanTransferMC,

+ Transfer: Transfer,

+ TransferMultiCoin: TransferMultiCoin,

+ GetHash: GetHashFn(header, chain),

+ Origin: msg.From(),

+ Coinbase: beneficiary,

+ BlockNumber: new(big.Int).Set(header.Number),

+ Time: new(big.Int).SetUint64(header.Time),

+ Difficulty: new(big.Int).Set(header.Difficulty),

+ GasLimit: header.GasLimit,

+ GasPrice: new(big.Int).Set(msg.GasPrice()),

+func CanTransferMC(db vm.StateDB, addr common.Address, to common.Address, coinID *common.Hash, amount *big.Int) int {

+ if coinID == nil {

+ return 0

+ }

+ if !db.IsMultiCoin(addr) {

+ err := db.EnableMultiCoin(addr)

+ log.Debug("try to enable MC", "addr", addr.Hex(), "err", err)

+ }

+ if !(db.IsMultiCoin(addr) && db.IsMultiCoin(to)) {

+ // incompatible

+ return -1

+ }

+ if db.GetBalanceMultiCoin(addr, *coinID).Cmp(amount) >= 0 {

+ return 0

+ }

+ // insufficient balance

+ return 1

+}

+

+

+// Transfer subtracts amount from sender and adds amount to recipient using the given Db

+func TransferMultiCoin(db vm.StateDB, sender, recipient common.Address, coinID *common.Hash, amount *big.Int) {

+ if coinID == nil {

+ return

+ }

+ db.SubBalanceMultiCoin(sender, *coinID, amount)

+ db.AddBalanceMultiCoin(recipient, *coinID, amount)

+}

+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.

+

+package core

+

+import (

+ "encoding/json"

+ "errors"

+ "math/big"

+

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/common/hexutil"

+ "github.com/ava-labs/go-ethereum/common/math"

+)

+

+var _ = (*genesisSpecMarshaling)(nil)

+

+// MarshalJSON marshals as JSON.

+func (g Genesis) MarshalJSON() ([]byte, error) {

+ type Genesis struct {

+ Config *params.ChainConfig `json:"config"`

+ Nonce math.HexOrDecimal64 `json:"nonce"`

+ Timestamp math.HexOrDecimal64 `json:"timestamp"`

+ ExtraData hexutil.Bytes `json:"extraData"`

+ GasLimit math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`

+ Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`

+ Mixhash common.Hash `json:"mixHash"`

+ Coinbase common.Address `json:"coinbase"`

+ Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"`

+ Number math.HexOrDecimal64 `json:"number"`

+ GasUsed math.HexOrDecimal64 `json:"gasUsed"`

+ ParentHash common.Hash `json:"parentHash"`

+ }

+ var enc Genesis

+ enc.Config = g.Config

+ enc.Nonce = math.HexOrDecimal64(g.Nonce)

+ enc.Timestamp = math.HexOrDecimal64(g.Timestamp)

+ enc.ExtraData = g.ExtraData

+ enc.GasLimit = math.HexOrDecimal64(g.GasLimit)

+ enc.Difficulty = (*math.HexOrDecimal256)(g.Difficulty)

+ enc.Mixhash = g.Mixhash

+ enc.Coinbase = g.Coinbase

+ if g.Alloc != nil {

+ enc.Alloc = make(map[common.UnprefixedAddress]GenesisAccount, len(g.Alloc))

+ for k, v := range g.Alloc {

+ enc.Alloc[common.UnprefixedAddress(k)] = v

+ }

+ }

+ enc.Number = math.HexOrDecimal64(g.Number)

+ enc.GasUsed = math.HexOrDecimal64(g.GasUsed)

+ enc.ParentHash = g.ParentHash

+ return json.Marshal(&enc)

+}

+

+// UnmarshalJSON unmarshals from JSON.

+func (g *Genesis) UnmarshalJSON(input []byte) error {

+ type Genesis struct {

+ Config *params.ChainConfig `json:"config"`

+ Nonce *math.HexOrDecimal64 `json:"nonce"`

+ Timestamp *math.HexOrDecimal64 `json:"timestamp"`

+ ExtraData *hexutil.Bytes `json:"extraData"`

+ GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"`

+ Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"`

+ Mixhash *common.Hash `json:"mixHash"`

+ Coinbase *common.Address `json:"coinbase"`

+ Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"`

+ Number *math.HexOrDecimal64 `json:"number"`

+ GasUsed *math.HexOrDecimal64 `json:"gasUsed"`

+ ParentHash *common.Hash `json:"parentHash"`

+ }

+ var dec Genesis

+ if err := json.Unmarshal(input, &dec); err != nil {

+ return err

+ }

+ if dec.Config != nil {

+ g.Config = dec.Config

+ }

+ if dec.Nonce != nil {

+ g.Nonce = uint64(*dec.Nonce)

+ }

+ if dec.Timestamp != nil {

+ g.Timestamp = uint64(*dec.Timestamp)

+ }

+ if dec.ExtraData != nil {

+ g.ExtraData = *dec.ExtraData

+ }

+ if dec.GasLimit == nil {

+ return errors.New("missing required field 'gasLimit' for Genesis")

+ }

+ g.GasLimit = uint64(*dec.GasLimit)

+ if dec.Difficulty == nil {

+ return errors.New("missing required field 'difficulty' for Genesis")

+ }

+ g.Difficulty = (*big.Int)(dec.Difficulty)

+ if dec.Mixhash != nil {

+ g.Mixhash = *dec.Mixhash

+ }

+ if dec.Coinbase != nil {

+ g.Coinbase = *dec.Coinbase

+ }

+ if dec.Alloc == nil {

+ return errors.New("missing required field 'alloc' for Genesis")

+ }

+ g.Alloc = make(GenesisAlloc, len(dec.Alloc))

+ for k, v := range dec.Alloc {

+ g.Alloc[common.Address(k)] = v

+ }

+ if dec.Number != nil {

+ g.Number = uint64(*dec.Number)

+ }

+ if dec.GasUsed != nil {

+ g.GasUsed = uint64(*dec.GasUsed)

+ }

+ if dec.ParentHash != nil {

+ g.ParentHash = *dec.ParentHash

+ }

+ return nil

+}

+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.

+

+package core

+

+import (

+ "encoding/json"

+ "errors"

+ "math/big"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/common/hexutil"

+ "github.com/ava-labs/go-ethereum/common/math"

+)

+

+var _ = (*genesisAccountMarshaling)(nil)

+

+// MarshalJSON marshals as JSON.

+func (g GenesisAccount) MarshalJSON() ([]byte, error) {

+ type GenesisAccount struct {

+ Code hexutil.Bytes `json:"code,omitempty"`

+ Storage map[storageJSON]storageJSON `json:"storage,omitempty"`

+ Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"`

+ MCBalance GenesisMultiCoinBalance `json:"mcbalance,omitempty"`

+ Nonce math.HexOrDecimal64 `json:"nonce,omitempty"`

+ PrivateKey hexutil.Bytes `json:"secretKey,omitempty"`

+ }

+ var enc GenesisAccount

+ enc.Code = g.Code

+ if g.Storage != nil {

+ enc.Storage = make(map[storageJSON]storageJSON, len(g.Storage))

+ for k, v := range g.Storage {

+ enc.Storage[storageJSON(k)] = storageJSON(v)

+ }

+ }

+ enc.Balance = (*math.HexOrDecimal256)(g.Balance)

+ enc.MCBalance = g.MCBalance

+ enc.Nonce = math.HexOrDecimal64(g.Nonce)

+ enc.PrivateKey = g.PrivateKey

+ return json.Marshal(&enc)

+}

+

+// UnmarshalJSON unmarshals from JSON.

+func (g *GenesisAccount) UnmarshalJSON(input []byte) error {

+ type GenesisAccount struct {

+ Code *hexutil.Bytes `json:"code,omitempty"`

+ Storage map[storageJSON]storageJSON `json:"storage,omitempty"`

+ Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"`

+ MCBalance *GenesisMultiCoinBalance `json:"mcbalance,omitempty"`

+ Nonce *math.HexOrDecimal64 `json:"nonce,omitempty"`

+ PrivateKey *hexutil.Bytes `json:"secretKey,omitempty"`

+ }

+ var dec GenesisAccount

+ if err := json.Unmarshal(input, &dec); err != nil {

+ return err

+ }

+ if dec.Code != nil {

+ g.Code = *dec.Code

+ }

+ if dec.Storage != nil {

+ g.Storage = make(map[common.Hash]common.Hash, len(dec.Storage))

+ for k, v := range dec.Storage {

+ g.Storage[common.Hash(k)] = common.Hash(v)

+ }

+ }

+ if dec.Balance == nil {

+ return errors.New("missing required field 'balance' for GenesisAccount")

+ }

+ g.Balance = (*big.Int)(dec.Balance)

+ if dec.MCBalance != nil {

+ g.MCBalance = *dec.MCBalance

+ }

+ if dec.Nonce != nil {

+ g.Nonce = uint64(*dec.Nonce)

+ }

+ if dec.PrivateKey != nil {

+ g.PrivateKey = *dec.PrivateKey

+ }

+ return nil

+}

+ "encoding/json"

+ "github.com/ava-labs/coreth/core/rawdb"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common/math"

+//go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go

+//go:generate gencodec -type GenesisAccount -field-override genesisAccountMarshaling -out gen_genesis_account.go

+

+// Genesis specifies the header fields, state of a genesis block. It also defines hard

+// fork switch-over blocks through the chain configuration.

+type Genesis struct {

+ Config *params.ChainConfig `json:"config"`

+ Nonce uint64 `json:"nonce"`

+ Timestamp uint64 `json:"timestamp"`

+ ExtraData []byte `json:"extraData"`

+ GasLimit uint64 `json:"gasLimit" gencodec:"required"`

+ Difficulty *big.Int `json:"difficulty" gencodec:"required"`

+ Mixhash common.Hash `json:"mixHash"`

+ Coinbase common.Address `json:"coinbase"`

+ Alloc GenesisAlloc `json:"alloc" gencodec:"required"`

+

+ // These fields are used for consensus tests. Please don't use them

+ // in actual genesis blocks.

+ Number uint64 `json:"number"`

+ GasUsed uint64 `json:"gasUsed"`

+ ParentHash common.Hash `json:"parentHash"`

+}

+

+// GenesisAlloc specifies the initial state that is part of the genesis block.

+type GenesisAlloc map[common.Address]GenesisAccount

+

+func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error {

+ m := make(map[common.UnprefixedAddress]GenesisAccount)

+ if err := json.Unmarshal(data, &m); err != nil {

+ return err

+ }

+ *ga = make(GenesisAlloc)

+ for addr, a := range m {

+ (*ga)[common.Address(addr)] = a

+ }

+ return nil

+}

+

+type GenesisMultiCoinBalance map[common.Hash]*big.Int

+

+// GenesisAccount is an account in the state of the genesis block.

+type GenesisAccount struct {

+ Code []byte `json:"code,omitempty"`

+ Storage map[common.Hash]common.Hash `json:"storage,omitempty"`

+ Balance *big.Int `json:"balance" gencodec:"required"`

+ MCBalance GenesisMultiCoinBalance `json:"mcbalance,omitempty"`

+ Nonce uint64 `json:"nonce,omitempty"`

+ PrivateKey []byte `json:"secretKey,omitempty"` // for tests

+}

+

+// field type overrides for gencodec

+type genesisSpecMarshaling struct {

+ Nonce math.HexOrDecimal64

+ Timestamp math.HexOrDecimal64

+ ExtraData hexutil.Bytes

+ GasLimit math.HexOrDecimal64

+ GasUsed math.HexOrDecimal64

+ Number math.HexOrDecimal64

+ Difficulty *math.HexOrDecimal256

+ Alloc map[common.UnprefixedAddress]GenesisAccount

+}

+

+type genesisAccountMarshaling struct {

+ Code hexutil.Bytes

+ Balance *math.HexOrDecimal256

+ Nonce math.HexOrDecimal64

+ Storage map[storageJSON]storageJSON

+ PrivateKey hexutil.Bytes

+}

+// ToBlock creates the genesis block and writes state of a genesis specification

+// to the given database (or discards it if nil).

+func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {

+ if db == nil {

+ db = rawdb.NewMemoryDatabase()

+ }

+ statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))

+ for addr, account := range g.Alloc {

+ statedb.AddBalance(addr, account.Balance)

+ statedb.SetCode(addr, account.Code)

+ statedb.SetNonce(addr, account.Nonce)

+ for key, value := range account.Storage {

+ statedb.SetState(addr, key, value)

+ }

+ if account.MCBalance != nil {

+ statedb.ForceEnableMultiCoin(addr)

+ for coinID, value := range account.MCBalance {

+ statedb.AddBalanceMultiCoin(addr, coinID, value)

+ }

+ }

+ }

+ root := statedb.IntermediateRoot(false)

+ head := &types.Header{

+ Number: new(big.Int).SetUint64(g.Number),

+ Nonce: types.EncodeNonce(g.Nonce),

+ Time: g.Timestamp,

+ ParentHash: g.ParentHash,

+ Extra: g.ExtraData,

+ GasLimit: g.GasLimit,

+ GasUsed: g.GasUsed,

+ Difficulty: g.Difficulty,

+ MixDigest: g.Mixhash,

+ Coinbase: g.Coinbase,

+ Root: root,

+ }

+ if g.GasLimit == 0 {

+ head.GasLimit = params.GenesisGasLimit

+ }

+ if g.Difficulty == nil {

+ head.Difficulty = params.GenesisDifficulty

+ }

+ statedb.Commit(false)

+ statedb.Database().TrieDB().Commit(root, true)

+

+ return types.NewBlock(head, nil, nil, nil)

+}

+

+// Commit writes the block and state of a genesis specification to the database.

+// The block is committed as the canonical head block.

+func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {

+ block := g.ToBlock(db)

+ if block.Number().Sign() != 0 {

+ return nil, fmt.Errorf("can't commit genesis block with number > 0")

+ }

+ rawdb.WriteTd(db, block.Hash(), block.NumberU64(), g.Difficulty)

+ rawdb.WriteBlock(db, block)

+ rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)

+ rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64())

+ rawdb.WriteHeadBlockHash(db, block.Hash())

+ rawdb.WriteHeadFastBlockHash(db, block.Hash())

+ rawdb.WriteHeadHeaderHash(db, block.Hash())

+

+ config := g.Config

+ if config == nil {

+ config = params.AllEthashProtocolChanges

+ }

+ rawdb.WriteChainConfig(db, block.Hash(), config)

+ return block, nil

+}

+

+// MustCommit writes the genesis block and state to db, panicking on error.

+// The block is committed as the canonical head block.

+func (g *Genesis) MustCommit(db ethdb.Database) *types.Block {

+ block, err := g.Commit(db)

+ if err != nil {

+ panic(err)

+ }

+ return block

+}

+

+// GenesisBlockForTesting creates and writes a block in which addr has the given wei balance.

+func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big.Int) *types.Block {

+ g := Genesis{Alloc: GenesisAlloc{addr: {Balance: balance}}}

+ return g.MustCommit(db)

+}

+

+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/core/rawdb"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/core"

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "bytes"

+ "encoding/binary"

+ "math/big"

+

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/rlp"

+)

+

+// ReadCanonicalHash retrieves the hash assigned to a canonical block number.

+func ReadCanonicalHash(db ethdb.Reader, number uint64) common.Hash {

+ data, _ := db.Ancient(freezerHashTable, number)

+ if len(data) == 0 {

+ data, _ = db.Get(headerHashKey(number))

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ if len(data) == 0 {

+ data, _ = db.Ancient(freezerHashTable, number)

+ }

+ }

+ if len(data) == 0 {

+ return common.Hash{}

+ }

+ return common.BytesToHash(data)

+}

+

+// WriteCanonicalHash stores the hash assigned to a canonical block number.

+func WriteCanonicalHash(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ if err := db.Put(headerHashKey(number), hash.Bytes()); err != nil {

+ log.Crit("Failed to store number to hash mapping", "err", err)

+ }

+}

+

+// DeleteCanonicalHash removes the number to hash canonical mapping.

+func DeleteCanonicalHash(db ethdb.KeyValueWriter, number uint64) {

+ if err := db.Delete(headerHashKey(number)); err != nil {

+ log.Crit("Failed to delete number to hash mapping", "err", err)

+ }

+}

+

+// ReadAllHashes retrieves all the hashes assigned to blocks at a certain heights,

+// both canonical and reorged forks included.

+func ReadAllHashes(db ethdb.Iteratee, number uint64) []common.Hash {

+ prefix := headerKeyPrefix(number)

+

+ hashes := make([]common.Hash, 0, 1)

+ it := db.NewIteratorWithPrefix(prefix)

+ defer it.Release()

+

+ for it.Next() {

+ if key := it.Key(); len(key) == len(prefix)+32 {

+ hashes = append(hashes, common.BytesToHash(key[len(key)-32:]))

+ }

+ }

+ return hashes

+}

+

+// ReadHeaderNumber returns the header number assigned to a hash.

+func ReadHeaderNumber(db ethdb.KeyValueReader, hash common.Hash) *uint64 {

+ data, _ := db.Get(headerNumberKey(hash))

+ if len(data) != 8 {

+ return nil

+ }

+ number := binary.BigEndian.Uint64(data)

+ return &number

+}

+

+// WriteHeaderNumber stores the hash->number mapping.

+func WriteHeaderNumber(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ key := headerNumberKey(hash)

+ enc := encodeBlockNumber(number)

+ if err := db.Put(key, enc); err != nil {

+ log.Crit("Failed to store hash to number mapping", "err", err)

+ }

+}

+

+// DeleteHeaderNumber removes hash->number mapping.

+func DeleteHeaderNumber(db ethdb.KeyValueWriter, hash common.Hash) {

+ if err := db.Delete(headerNumberKey(hash)); err != nil {

+ log.Crit("Failed to delete hash to number mapping", "err", err)

+ }

+}

+

+// ReadHeadHeaderHash retrieves the hash of the current canonical head header.

+func ReadHeadHeaderHash(db ethdb.KeyValueReader) common.Hash {

+ data, _ := db.Get(headHeaderKey)

+ if len(data) == 0 {

+ return common.Hash{}

+ }

+ return common.BytesToHash(data)

+}

+

+// WriteHeadHeaderHash stores the hash of the current canonical head header.

+func WriteHeadHeaderHash(db ethdb.KeyValueWriter, hash common.Hash) {

+ if err := db.Put(headHeaderKey, hash.Bytes()); err != nil {

+ log.Crit("Failed to store last header's hash", "err", err)

+ }

+}

+

+// ReadHeadBlockHash retrieves the hash of the current canonical head block.

+func ReadHeadBlockHash(db ethdb.KeyValueReader) common.Hash {

+ data, _ := db.Get(headBlockKey)

+ if len(data) == 0 {

+ return common.Hash{}

+ }

+ return common.BytesToHash(data)

+}

+

+// WriteHeadBlockHash stores the head block's hash.

+func WriteHeadBlockHash(db ethdb.KeyValueWriter, hash common.Hash) {

+ if err := db.Put(headBlockKey, hash.Bytes()); err != nil {

+ log.Crit("Failed to store last block's hash", "err", err)

+ }

+}

+

+// ReadHeadFastBlockHash retrieves the hash of the current fast-sync head block.

+func ReadHeadFastBlockHash(db ethdb.KeyValueReader) common.Hash {

+ data, _ := db.Get(headFastBlockKey)

+ if len(data) == 0 {

+ return common.Hash{}

+ }

+ return common.BytesToHash(data)

+}

+

+// WriteHeadFastBlockHash stores the hash of the current fast-sync head block.

+func WriteHeadFastBlockHash(db ethdb.KeyValueWriter, hash common.Hash) {

+ if err := db.Put(headFastBlockKey, hash.Bytes()); err != nil {

+ log.Crit("Failed to store last fast block's hash", "err", err)

+ }

+}

+

+// ReadFastTrieProgress retrieves the number of tries nodes fast synced to allow

+// reporting correct numbers across restarts.

+func ReadFastTrieProgress(db ethdb.KeyValueReader) uint64 {

+ data, _ := db.Get(fastTrieProgressKey)

+ if len(data) == 0 {

+ return 0

+ }

+ return new(big.Int).SetBytes(data).Uint64()

+}

+

+// WriteFastTrieProgress stores the fast sync trie process counter to support

+// retrieving it across restarts.

+func WriteFastTrieProgress(db ethdb.KeyValueWriter, count uint64) {

+ if err := db.Put(fastTrieProgressKey, new(big.Int).SetUint64(count).Bytes()); err != nil {

+ log.Crit("Failed to store fast sync trie progress", "err", err)

+ }

+}

+

+// ReadHeaderRLP retrieves a block header in its raw RLP database encoding.

+func ReadHeaderRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {

+ data, _ := db.Ancient(freezerHeaderTable, number)

+ if len(data) == 0 {

+ data, _ = db.Get(headerKey(number, hash))

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ if len(data) == 0 {

+ data, _ = db.Ancient(freezerHeaderTable, number)

+ }

+ }

+ return data

+}

+

+// HasHeader verifies the existence of a block header corresponding to the hash.

+func HasHeader(db ethdb.Reader, hash common.Hash, number uint64) bool {

+ if has, err := db.Ancient(freezerHashTable, number); err == nil && common.BytesToHash(has) == hash {

+ return true

+ }

+ if has, err := db.Has(headerKey(number, hash)); !has || err != nil {

+ return false

+ }

+ return true

+}

+

+// ReadHeader retrieves the block header corresponding to the hash.

+func ReadHeader(db ethdb.Reader, hash common.Hash, number uint64) *types.Header {

+ data := ReadHeaderRLP(db, hash, number)

+ if len(data) == 0 {

+ return nil

+ }

+ header := new(types.Header)

+ if err := rlp.Decode(bytes.NewReader(data), header); err != nil {

+ log.Error("Invalid block header RLP", "hash", hash, "err", err)

+ return nil

+ }

+ return header

+}

+

+// WriteHeader stores a block header into the database and also stores the hash-

+// to-number mapping.

+func WriteHeader(db ethdb.KeyValueWriter, header *types.Header) {

+ var (

+ hash = header.Hash()

+ number = header.Number.Uint64()

+ )

+ // Write the hash -> number mapping

+ WriteHeaderNumber(db, hash, number)

+

+ // Write the encoded header

+ data, err := rlp.EncodeToBytes(header)

+ if err != nil {

+ log.Crit("Failed to RLP encode header", "err", err)

+ }

+ key := headerKey(number, hash)

+ if err := db.Put(key, data); err != nil {

+ log.Crit("Failed to store header", "err", err)

+ }

+}

+

+// DeleteHeader removes all block header data associated with a hash.

+func DeleteHeader(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ deleteHeaderWithoutNumber(db, hash, number)

+ if err := db.Delete(headerNumberKey(hash)); err != nil {

+ log.Crit("Failed to delete hash to number mapping", "err", err)

+ }

+}

+

+// deleteHeaderWithoutNumber removes only the block header but does not remove

+// the hash to number mapping.

+func deleteHeaderWithoutNumber(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ if err := db.Delete(headerKey(number, hash)); err != nil {

+ log.Crit("Failed to delete header", "err", err)

+ }

+}

+

+// ReadBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.

+func ReadBodyRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {

+ data, _ := db.Ancient(freezerBodiesTable, number)

+ if len(data) == 0 {

+ data, _ = db.Get(blockBodyKey(number, hash))

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ if len(data) == 0 {

+ data, _ = db.Ancient(freezerBodiesTable, number)

+ }

+ }

+ return data

+}

+

+// WriteBodyRLP stores an RLP encoded block body into the database.

+func WriteBodyRLP(db ethdb.KeyValueWriter, hash common.Hash, number uint64, rlp rlp.RawValue) {

+ if err := db.Put(blockBodyKey(number, hash), rlp); err != nil {

+ log.Crit("Failed to store block body", "err", err)

+ }

+}

+

+// HasBody verifies the existence of a block body corresponding to the hash.

+func HasBody(db ethdb.Reader, hash common.Hash, number uint64) bool {

+ if has, err := db.Ancient(freezerHashTable, number); err == nil && common.BytesToHash(has) == hash {

+ return true

+ }

+ if has, err := db.Has(blockBodyKey(number, hash)); !has || err != nil {

+ return false

+ }

+ return true

+}

+

+// ReadBody retrieves the block body corresponding to the hash.

+func ReadBody(db ethdb.Reader, hash common.Hash, number uint64) *types.Body {

+ data := ReadBodyRLP(db, hash, number)

+ if len(data) == 0 {

+ return nil

+ }

+ body := new(types.Body)

+ if err := rlp.Decode(bytes.NewReader(data), body); err != nil {

+ log.Error("Invalid block body RLP", "hash", hash, "err", err)

+ return nil

+ }

+ return body

+}

+

+// WriteBody stores a block body into the database.

+func WriteBody(db ethdb.KeyValueWriter, hash common.Hash, number uint64, body *types.Body) {

+ data, err := rlp.EncodeToBytes(body)

+ if err != nil {

+ log.Crit("Failed to RLP encode body", "err", err)

+ }

+ WriteBodyRLP(db, hash, number, data)

+}

+

+// DeleteBody removes all block body data associated with a hash.

+func DeleteBody(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ if err := db.Delete(blockBodyKey(number, hash)); err != nil {

+ log.Crit("Failed to delete block body", "err", err)

+ }

+}

+

+// ReadTdRLP retrieves a block's total difficulty corresponding to the hash in RLP encoding.

+func ReadTdRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {

+ data, _ := db.Ancient(freezerDifficultyTable, number)

+ if len(data) == 0 {

+ data, _ = db.Get(headerTDKey(number, hash))

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ if len(data) == 0 {

+ data, _ = db.Ancient(freezerDifficultyTable, number)

+ }

+ }

+ return data

+}

+

+// ReadTd retrieves a block's total difficulty corresponding to the hash.

+func ReadTd(db ethdb.Reader, hash common.Hash, number uint64) *big.Int {

+ data := ReadTdRLP(db, hash, number)

+ if len(data) == 0 {

+ return nil

+ }

+ td := new(big.Int)

+ if err := rlp.Decode(bytes.NewReader(data), td); err != nil {

+ log.Error("Invalid block total difficulty RLP", "hash", hash, "err", err)

+ return nil

+ }

+ return td

+}

+

+// WriteTd stores the total difficulty of a block into the database.

+func WriteTd(db ethdb.KeyValueWriter, hash common.Hash, number uint64, td *big.Int) {

+ data, err := rlp.EncodeToBytes(td)

+ if err != nil {

+ log.Crit("Failed to RLP encode block total difficulty", "err", err)

+ }

+ if err := db.Put(headerTDKey(number, hash), data); err != nil {

+ log.Crit("Failed to store block total difficulty", "err", err)

+ }

+}

+

+// DeleteTd removes all block total difficulty data associated with a hash.

+func DeleteTd(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ if err := db.Delete(headerTDKey(number, hash)); err != nil {

+ log.Crit("Failed to delete block total difficulty", "err", err)

+ }

+}

+

+// HasReceipts verifies the existence of all the transaction receipts belonging

+// to a block.

+func HasReceipts(db ethdb.Reader, hash common.Hash, number uint64) bool {

+ if has, err := db.Ancient(freezerHashTable, number); err == nil && common.BytesToHash(has) == hash {

+ return true

+ }

+ if has, err := db.Has(blockReceiptsKey(number, hash)); !has || err != nil {

+ return false

+ }

+ return true

+}

+

+// ReadReceiptsRLP retrieves all the transaction receipts belonging to a block in RLP encoding.

+func ReadReceiptsRLP(db ethdb.Reader, hash common.Hash, number uint64) rlp.RawValue {

+ data, _ := db.Ancient(freezerReceiptTable, number)

+ if len(data) == 0 {

+ data, _ = db.Get(blockReceiptsKey(number, hash))

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ if len(data) == 0 {

+ data, _ = db.Ancient(freezerReceiptTable, number)

+ }

+ }

+ return data

+}

+

+// ReadRawReceipts retrieves all the transaction receipts belonging to a block.

+// The receipt metadata fields are not guaranteed to be populated, so they

+// should not be used. Use ReadReceipts instead if the metadata is needed.

+func ReadRawReceipts(db ethdb.Reader, hash common.Hash, number uint64) types.Receipts {

+ // Retrieve the flattened receipt slice

+ data := ReadReceiptsRLP(db, hash, number)

+ if len(data) == 0 {

+ return nil

+ }

+ // Convert the receipts from their storage form to their internal representation

+ storageReceipts := []*types.ReceiptForStorage{}

+ if err := rlp.DecodeBytes(data, &storageReceipts); err != nil {

+ log.Error("Invalid receipt array RLP", "hash", hash, "err", err)

+ return nil

+ }

+ receipts := make(types.Receipts, len(storageReceipts))

+ for i, storageReceipt := range storageReceipts {

+ receipts[i] = (*types.Receipt)(storageReceipt)

+ }

+ return receipts

+}

+

+// ReadReceipts retrieves all the transaction receipts belonging to a block, including

+// its correspoinding metadata fields. If it is unable to populate these metadata

+// fields then nil is returned.

+//

+// The current implementation populates these metadata fields by reading the receipts'

+// corresponding block body, so if the block body is not found it will return nil even

+// if the receipt itself is stored.

+func ReadReceipts(db ethdb.Reader, hash common.Hash, number uint64, config *params.ChainConfig) types.Receipts {

+ // We're deriving many fields from the block body, retrieve beside the receipt

+ receipts := ReadRawReceipts(db, hash, number)

+ if receipts == nil {

+ return nil

+ }

+ body := ReadBody(db, hash, number)

+ if body == nil {

+ log.Error("Missing body but have receipt", "hash", hash, "number", number)

+ return nil

+ }

+ if err := receipts.DeriveFields(config, hash, number, body.Transactions); err != nil {

+ log.Error("Failed to derive block receipts fields", "hash", hash, "number", number, "err", err)

+ return nil

+ }

+ return receipts

+}

+

+// WriteReceipts stores all the transaction receipts belonging to a block.

+func WriteReceipts(db ethdb.KeyValueWriter, hash common.Hash, number uint64, receipts types.Receipts) {

+ // Convert the receipts into their storage form and serialize them

+ storageReceipts := make([]*types.ReceiptForStorage, len(receipts))

+ for i, receipt := range receipts {

+ storageReceipts[i] = (*types.ReceiptForStorage)(receipt)

+ }

+ bytes, err := rlp.EncodeToBytes(storageReceipts)

+ if err != nil {

+ log.Crit("Failed to encode block receipts", "err", err)

+ }

+ // Store the flattened receipt slice

+ if err := db.Put(blockReceiptsKey(number, hash), bytes); err != nil {

+ log.Crit("Failed to store block receipts", "err", err)

+ }

+}

+

+// DeleteReceipts removes all receipt data associated with a block hash.

+func DeleteReceipts(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ if err := db.Delete(blockReceiptsKey(number, hash)); err != nil {

+ log.Crit("Failed to delete block receipts", "err", err)

+ }

+}

+

+// ReadBlock retrieves an entire block corresponding to the hash, assembling it

+// back from the stored header and body. If either the header or body could not

+// be retrieved nil is returned.

+//

+// Note, due to concurrent download of header and block body the header and thus

+// canonical hash can be stored in the database but the body data not (yet).

+func ReadBlock(db ethdb.Reader, hash common.Hash, number uint64) *types.Block {

+ header := ReadHeader(db, hash, number)

+ if header == nil {

+ return nil

+ }

+ body := ReadBody(db, hash, number)

+ if body == nil {

+ return nil

+ }

+ return types.NewBlockWithHeader(header).WithBody(body.Transactions, body.Uncles)

+}

+

+// WriteBlock serializes a block into the database, header and body separately.

+func WriteBlock(db ethdb.KeyValueWriter, block *types.Block) {

+ WriteBody(db, block.Hash(), block.NumberU64(), block.Body())

+ WriteHeader(db, block.Header())

+}

+

+// WriteAncientBlock writes entire block data into ancient store and returns the total written size.

+func WriteAncientBlock(db ethdb.AncientWriter, block *types.Block, receipts types.Receipts, td *big.Int) int {

+ // Encode all block components to RLP format.

+ headerBlob, err := rlp.EncodeToBytes(block.Header())

+ if err != nil {

+ log.Crit("Failed to RLP encode block header", "err", err)

+ }

+ bodyBlob, err := rlp.EncodeToBytes(block.Body())

+ if err != nil {

+ log.Crit("Failed to RLP encode body", "err", err)

+ }

+ storageReceipts := make([]*types.ReceiptForStorage, len(receipts))

+ for i, receipt := range receipts {

+ storageReceipts[i] = (*types.ReceiptForStorage)(receipt)

+ }

+ receiptBlob, err := rlp.EncodeToBytes(storageReceipts)

+ if err != nil {

+ log.Crit("Failed to RLP encode block receipts", "err", err)

+ }

+ tdBlob, err := rlp.EncodeToBytes(td)

+ if err != nil {

+ log.Crit("Failed to RLP encode block total difficulty", "err", err)

+ }

+ // Write all blob to flatten files.

+ err = db.AppendAncient(block.NumberU64(), block.Hash().Bytes(), headerBlob, bodyBlob, receiptBlob, tdBlob)

+ if err != nil {

+ log.Crit("Failed to write block data to ancient store", "err", err)

+ }

+ return len(headerBlob) + len(bodyBlob) + len(receiptBlob) + len(tdBlob) + common.HashLength

+}

+

+// DeleteBlock removes all block data associated with a hash.

+func DeleteBlock(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ DeleteReceipts(db, hash, number)

+ DeleteHeader(db, hash, number)

+ DeleteBody(db, hash, number)

+ DeleteTd(db, hash, number)

+}

+

+// DeleteBlockWithoutNumber removes all block data associated with a hash, except

+// the hash to number mapping.

+func DeleteBlockWithoutNumber(db ethdb.KeyValueWriter, hash common.Hash, number uint64) {

+ DeleteReceipts(db, hash, number)

+ deleteHeaderWithoutNumber(db, hash, number)

+ DeleteBody(db, hash, number)

+ DeleteTd(db, hash, number)

+}

+

+// FindCommonAncestor returns the last common ancestor of two block headers

+func FindCommonAncestor(db ethdb.Reader, a, b *types.Header) *types.Header {

+ for bn := b.Number.Uint64(); a.Number.Uint64() > bn; {

+ a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1)

+ if a == nil {

+ return nil

+ }

+ }

+ for an := a.Number.Uint64(); an < b.Number.Uint64(); {

+ b = ReadHeader(db, b.ParentHash, b.Number.Uint64()-1)

+ if b == nil {

+ return nil

+ }

+ }

+ for a.Hash() != b.Hash() {

+ a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1)

+ if a == nil {

+ return nil

+ }

+ b = ReadHeader(db, b.ParentHash, b.Number.Uint64()-1)

+ if b == nil {

+ return nil

+ }

+ }

+ return a

+}

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "math/big"

+

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/rlp"

+)

+

+// ReadTxLookupEntry retrieves the positional metadata associated with a transaction

+// hash to allow retrieving the transaction or receipt by hash.

+func ReadTxLookupEntry(db ethdb.Reader, hash common.Hash) *uint64 {

+ data, _ := db.Get(txLookupKey(hash))

+ if len(data) == 0 {

+ return nil

+ }

+ // Database v6 tx lookup just stores the block number

+ if len(data) < common.HashLength {

+ number := new(big.Int).SetBytes(data).Uint64()

+ return &number

+ }

+ // Database v4-v5 tx lookup format just stores the hash

+ if len(data) == common.HashLength {

+ return ReadHeaderNumber(db, common.BytesToHash(data))

+ }

+ // Finally try database v3 tx lookup format

+ var entry LegacyTxLookupEntry

+ if err := rlp.DecodeBytes(data, &entry); err != nil {

+ log.Error("Invalid transaction lookup entry RLP", "hash", hash, "blob", data, "err", err)

+ return nil

+ }

+ return &entry.BlockIndex

+}

+

+// WriteTxLookupEntries stores a positional metadata for every transaction from

+// a block, enabling hash based transaction and receipt lookups.

+func WriteTxLookupEntries(db ethdb.KeyValueWriter, block *types.Block) {

+ number := block.Number().Bytes()

+ for _, tx := range block.Transactions() {

+ if err := db.Put(txLookupKey(tx.Hash()), number); err != nil {

+ log.Crit("Failed to store transaction lookup entry", "err", err)

+ }

+ }

+}

+

+// DeleteTxLookupEntry removes all transaction data associated with a hash.

+func DeleteTxLookupEntry(db ethdb.KeyValueWriter, hash common.Hash) {

+ db.Delete(txLookupKey(hash))

+}

+

+// ReadTransaction retrieves a specific transaction from the database, along with

+// its added positional metadata.

+func ReadTransaction(db ethdb.Reader, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {

+ blockNumber := ReadTxLookupEntry(db, hash)

+ if blockNumber == nil {

+ return nil, common.Hash{}, 0, 0

+ }

+ blockHash := ReadCanonicalHash(db, *blockNumber)

+ if blockHash == (common.Hash{}) {

+ return nil, common.Hash{}, 0, 0

+ }

+ body := ReadBody(db, blockHash, *blockNumber)

+ if body == nil {

+ log.Error("Transaction referenced missing", "number", blockNumber, "hash", blockHash)

+ return nil, common.Hash{}, 0, 0

+ }

+ for txIndex, tx := range body.Transactions {

+ if tx.Hash() == hash {

+ return tx, blockHash, *blockNumber, uint64(txIndex)

+ }

+ }

+ log.Error("Transaction not found", "number", blockNumber, "hash", blockHash, "txhash", hash)

+ return nil, common.Hash{}, 0, 0

+}

+

+// ReadReceipt retrieves a specific transaction receipt from the database, along with

+// its added positional metadata.

+func ReadReceipt(db ethdb.Reader, hash common.Hash, config *params.ChainConfig) (*types.Receipt, common.Hash, uint64, uint64) {

+ // Retrieve the context of the receipt based on the transaction hash

+ blockNumber := ReadTxLookupEntry(db, hash)

+ if blockNumber == nil {

+ return nil, common.Hash{}, 0, 0

+ }

+ blockHash := ReadCanonicalHash(db, *blockNumber)

+ if blockHash == (common.Hash{}) {

+ return nil, common.Hash{}, 0, 0

+ }

+ // Read all the receipts from the block and return the one with the matching hash

+ receipts := ReadReceipts(db, blockHash, *blockNumber, config)

+ for receiptIndex, receipt := range receipts {

+ if receipt.TxHash == hash {

+ return receipt, blockHash, *blockNumber, uint64(receiptIndex)

+ }

+ }

+ log.Error("Receipt not found", "number", blockNumber, "hash", blockHash, "txhash", hash)

+ return nil, common.Hash{}, 0, 0

+}

+

+// ReadBloomBits retrieves the compressed bloom bit vector belonging to the given

+// section and bit index from the.

+func ReadBloomBits(db ethdb.KeyValueReader, bit uint, section uint64, head common.Hash) ([]byte, error) {

+ return db.Get(bloomBitsKey(bit, section, head))

+}

+

+// WriteBloomBits stores the compressed bloom bits vector belonging to the given

+// section and bit index.

+func WriteBloomBits(db ethdb.KeyValueWriter, bit uint, section uint64, head common.Hash, bits []byte) {

+ if err := db.Put(bloomBitsKey(bit, section, head), bits); err != nil {

+ log.Crit("Failed to store bloom bits", "err", err)

+ }

+}

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "encoding/json"

+

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/rlp"

+)

+

+// ReadDatabaseVersion retrieves the version number of the database.

+func ReadDatabaseVersion(db ethdb.KeyValueReader) *uint64 {

+ var version uint64

+

+ enc, _ := db.Get(databaseVerisionKey)

+ if len(enc) == 0 {

+ return nil

+ }

+ if err := rlp.DecodeBytes(enc, &version); err != nil {

+ return nil

+ }

+

+ return &version

+}

+

+// WriteDatabaseVersion stores the version number of the database

+func WriteDatabaseVersion(db ethdb.KeyValueWriter, version uint64) {

+ enc, err := rlp.EncodeToBytes(version)

+ if err != nil {

+ log.Crit("Failed to encode database version", "err", err)

+ }

+ if err = db.Put(databaseVerisionKey, enc); err != nil {

+ log.Crit("Failed to store the database version", "err", err)

+ }

+}

+

+// ReadChainConfig retrieves the consensus settings based on the given genesis hash.

+func ReadChainConfig(db ethdb.KeyValueReader, hash common.Hash) *params.ChainConfig {

+ data, _ := db.Get(configKey(hash))

+ if len(data) == 0 {

+ return nil

+ }

+ var config params.ChainConfig

+ if err := json.Unmarshal(data, &config); err != nil {

+ log.Error("Invalid chain config JSON", "hash", hash, "err", err)

+ return nil

+ }

+ return &config

+}

+

+// WriteChainConfig writes the chain config settings to the database.

+func WriteChainConfig(db ethdb.KeyValueWriter, hash common.Hash, cfg *params.ChainConfig) {

+ if cfg == nil {

+ return

+ }

+ data, err := json.Marshal(cfg)

+ if err != nil {

+ log.Crit("Failed to JSON encode chain config", "err", err)

+ }

+ if err := db.Put(configKey(hash), data); err != nil {

+ log.Crit("Failed to store chain config", "err", err)

+ }

+}

+

+// ReadPreimage retrieves a single preimage of the provided hash.

+func ReadPreimage(db ethdb.KeyValueReader, hash common.Hash) []byte {

+ data, _ := db.Get(preimageKey(hash))

+ return data

+}

+

+// WritePreimages writes the provided set of preimages to the database.

+func WritePreimages(db ethdb.KeyValueWriter, preimages map[common.Hash][]byte) {

+ for hash, preimage := range preimages {

+ if err := db.Put(preimageKey(hash), preimage); err != nil {

+ log.Crit("Failed to store trie preimage", "err", err)

+ }

+ }

+ preimageCounter.Inc(int64(len(preimages)))

+ preimageHitCounter.Inc(int64(len(preimages)))

+}

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "bytes"

+ "errors"

+ "fmt"

+ "os"

+ "time"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/ethdb/leveldb"

+ "github.com/ava-labs/go-ethereum/ethdb/memorydb"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/olekukonko/tablewriter"

+)

+

+// freezerdb is a database wrapper that enabled freezer data retrievals.

+type freezerdb struct {

+ ethdb.KeyValueStore

+ ethdb.AncientStore

+}

+

+// Close implements io.Closer, closing both the fast key-value store as well as

+// the slow ancient tables.

+func (frdb *freezerdb) Close() error {

+ var errs []error

+ if err := frdb.KeyValueStore.Close(); err != nil {

+ errs = append(errs, err)

+ }

+ if err := frdb.AncientStore.Close(); err != nil {

+ errs = append(errs, err)

+ }

+ if len(errs) != 0 {

+ return fmt.Errorf("%v", errs)

+ }

+ return nil

+}

+

+// nofreezedb is a database wrapper that disables freezer data retrievals.

+type nofreezedb struct {

+ ethdb.KeyValueStore

+}

+

+// HasAncient returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) HasAncient(kind string, number uint64) (bool, error) {

+ return false, errNotSupported

+}

+

+// Ancient returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) Ancient(kind string, number uint64) ([]byte, error) {

+ return nil, errNotSupported

+}

+

+// Ancients returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) Ancients() (uint64, error) {

+ return 0, errNotSupported

+}

+

+// AncientSize returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) AncientSize(kind string) (uint64, error) {

+ return 0, errNotSupported

+}

+

+// AppendAncient returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) AppendAncient(number uint64, hash, header, body, receipts, td []byte) error {

+ return errNotSupported

+}

+

+// TruncateAncients returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) TruncateAncients(items uint64) error {

+ return errNotSupported

+}

+

+// Sync returns an error as we don't have a backing chain freezer.

+func (db *nofreezedb) Sync() error {

+ return errNotSupported

+}

+

+// NewDatabase creates a high level database on top of a given key-value data

+// store without a freezer moving immutable chain segments into cold storage.

+func NewDatabase(db ethdb.KeyValueStore) ethdb.Database {

+ return &nofreezedb{

+ KeyValueStore: db,

+ }

+}

+

+// NewDatabaseWithFreezer creates a high level database on top of a given key-

+// value data store with a freezer moving immutable chain segments into cold

+// storage.

+func NewDatabaseWithFreezer(db ethdb.KeyValueStore, freezer string, namespace string) (ethdb.Database, error) {

+ // Create the idle freezer instance

+ frdb, err := newFreezer(freezer, namespace)

+ if err != nil {

+ return nil, err

+ }

+ // Since the freezer can be stored separately from the user's key-value database,

+ // there's a fairly high probability that the user requests invalid combinations

+ // of the freezer and database. Ensure that we don't shoot ourselves in the foot

+ // by serving up conflicting data, leading to both datastores getting corrupted.

+ //

+ // - If both the freezer and key-value store is empty (no genesis), we just

+ // initialized a new empty freezer, so everything's fine.

+ // - If the key-value store is empty, but the freezer is not, we need to make

+ // sure the user's genesis matches the freezer. That will be checked in the

+ // blockchain, since we don't have the genesis block here (nor should we at

+ // this point care, the key-value/freezer combo is valid).

+ // - If neither the key-value store nor the freezer is empty, cross validate

+ // the genesis hashes to make sure they are compatible. If they are, also

+ // ensure that there's no gap between the freezer and sunsequently leveldb.

+ // - If the key-value store is not empty, but the freezer is we might just be

+ // upgrading to the freezer release, or we might have had a small chain and

+ // not frozen anything yet. Ensure that no blocks are missing yet from the

+ // key-value store, since that would mean we already had an old freezer.

+

+ // If the genesis hash is empty, we have a new key-value store, so nothing to

+ // validate in this method. If, however, the genesis hash is not nil, compare

+ // it to the freezer content.

+ if kvgenesis, _ := db.Get(headerHashKey(0)); len(kvgenesis) > 0 {

+ if frozen, _ := frdb.Ancients(); frozen > 0 {

+ // If the freezer already contains something, ensure that the genesis blocks

+ // match, otherwise we might mix up freezers across chains and destroy both

+ // the freezer and the key-value store.

+ if frgenesis, _ := frdb.Ancient(freezerHashTable, 0); !bytes.Equal(kvgenesis, frgenesis) {

+ return nil, fmt.Errorf("genesis mismatch: %#x (leveldb) != %#x (ancients)", kvgenesis, frgenesis)

+ }

+ // Key-value store and freezer belong to the same network. Ensure that they

+ // are contiguous, otherwise we might end up with a non-functional freezer.

+ if kvhash, _ := db.Get(headerHashKey(frozen)); len(kvhash) == 0 {

+ // Subsequent header after the freezer limit is missing from the database.

+ // Reject startup is the database has a more recent head.

+ if *ReadHeaderNumber(db, ReadHeadHeaderHash(db)) > frozen-1 {

+ return nil, fmt.Errorf("gap (#%d) in the chain between ancients and leveldb", frozen)

+ }

+ // Database contains only older data than the freezer, this happens if the

+ // state was wiped and reinited from an existing freezer.

+ } else {

+ // Key-value store continues where the freezer left off, all is fine. We might

+ // have duplicate blocks (crash after freezer write but before kay-value store

+ // deletion, but that's fine).

+ }

+ } else {

+ // If the freezer is empty, ensure nothing was moved yet from the key-value

+ // store, otherwise we'll end up missing data. We check block #1 to decide

+ // if we froze anything previously or not, but do take care of databases with

+ // only the genesis block.

+ if ReadHeadHeaderHash(db) != common.BytesToHash(kvgenesis) {

+ // Key-value store contains more data than the genesis block, make sure we

+ // didn't freeze anything yet.

+ if kvblob, _ := db.Get(headerHashKey(1)); len(kvblob) == 0 {

+ return nil, errors.New("ancient chain segments already extracted, please set --datadir.ancient to the correct path")

+ }

+ // Block #1 is still in the database, we're allowed to init a new feezer

+ } else {

+ // The head header is still the genesis, we're allowed to init a new feezer

+ }

+ }

+ }

+ // Freezer is consistent with the key-value database, permit combining the two

+ go frdb.freeze(db)

+

+ return &freezerdb{

+ KeyValueStore: db,

+ AncientStore: frdb,

+ }, nil

+}

+

+// NewMemoryDatabase creates an ephemeral in-memory key-value database without a

+// freezer moving immutable chain segments into cold storage.

+func NewMemoryDatabase() ethdb.Database {

+ return NewDatabase(memorydb.New())

+}

+

+// NewMemoryDatabaseWithCap creates an ephemeral in-memory key-value database

+// with an initial starting capacity, but without a freezer moving immutable

+// chain segments into cold storage.

+func NewMemoryDatabaseWithCap(size int) ethdb.Database {

+ return NewDatabase(memorydb.NewWithCap(size))

+}

+

+// NewLevelDBDatabase creates a persistent key-value database without a freezer

+// moving immutable chain segments into cold storage.

+func NewLevelDBDatabase(file string, cache int, handles int, namespace string) (ethdb.Database, error) {

+ db, err := leveldb.New(file, cache, handles, namespace)

+ if err != nil {

+ return nil, err

+ }

+ return NewDatabase(db), nil

+}

+

+// NewLevelDBDatabaseWithFreezer creates a persistent key-value database with a

+// freezer moving immutable chain segments into cold storage.

+func NewLevelDBDatabaseWithFreezer(file string, cache int, handles int, freezer string, namespace string) (ethdb.Database, error) {

+ kvdb, err := leveldb.New(file, cache, handles, namespace)

+ if err != nil {

+ return nil, err

+ }

+ frdb, err := NewDatabaseWithFreezer(kvdb, freezer, namespace)

+ if err != nil {

+ kvdb.Close()

+ return nil, err

+ }

+ return frdb, nil

+}

+

+// InspectDatabase traverses the entire database and checks the size

+// of all different categories of data.

+func InspectDatabase(db ethdb.Database) error {

+ it := db.NewIterator()

+ defer it.Release()

+

+ var (

+ count int64

+ start = time.Now()

+ logged = time.Now()

+

+ // Key-value store statistics

+ total common.StorageSize

+ headerSize common.StorageSize

+ bodySize common.StorageSize

+ receiptSize common.StorageSize

+ tdSize common.StorageSize

+ numHashPairing common.StorageSize

+ hashNumPairing common.StorageSize

+ trieSize common.StorageSize

+ txlookupSize common.StorageSize

+ preimageSize common.StorageSize

+ bloomBitsSize common.StorageSize

+ cliqueSnapsSize common.StorageSize

+

+ // Ancient store statistics

+ ancientHeaders common.StorageSize

+ ancientBodies common.StorageSize

+ ancientReceipts common.StorageSize

+ ancientHashes common.StorageSize

+ ancientTds common.StorageSize

+

+ // Les statistic

+ chtTrieNodes common.StorageSize

+ bloomTrieNodes common.StorageSize

+

+ // Meta- and unaccounted data

+ metadata common.StorageSize

+ unaccounted common.StorageSize

+ )

+ // Inspect key-value database first.

+ for it.Next() {

+ var (

+ key = it.Key()

+ size = common.StorageSize(len(key) + len(it.Value()))

+ )

+ total += size

+ switch {

+ case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerTDSuffix):

+ tdSize += size

+ case bytes.HasPrefix(key, headerPrefix) && bytes.HasSuffix(key, headerHashSuffix):

+ numHashPairing += size

+ case bytes.HasPrefix(key, headerPrefix) && len(key) == (len(headerPrefix)+8+common.HashLength):

+ headerSize += size

+ case bytes.HasPrefix(key, headerNumberPrefix) && len(key) == (len(headerNumberPrefix)+common.HashLength):

+ hashNumPairing += size

+ case bytes.HasPrefix(key, blockBodyPrefix) && len(key) == (len(blockBodyPrefix)+8+common.HashLength):

+ bodySize += size

+ case bytes.HasPrefix(key, blockReceiptsPrefix) && len(key) == (len(blockReceiptsPrefix)+8+common.HashLength):

+ receiptSize += size

+ case bytes.HasPrefix(key, txLookupPrefix) && len(key) == (len(txLookupPrefix)+common.HashLength):

+ txlookupSize += size

+ case bytes.HasPrefix(key, preimagePrefix) && len(key) == (len(preimagePrefix)+common.HashLength):

+ preimageSize += size

+ case bytes.HasPrefix(key, bloomBitsPrefix) && len(key) == (len(bloomBitsPrefix)+10+common.HashLength):

+ bloomBitsSize += size

+ case bytes.HasPrefix(key, []byte("clique-")) && len(key) == 7+common.HashLength:

+ cliqueSnapsSize += size

+ case bytes.HasPrefix(key, []byte("cht-")) && len(key) == 4+common.HashLength:

+ chtTrieNodes += size

+ case bytes.HasPrefix(key, []byte("blt-")) && len(key) == 4+common.HashLength:

+ bloomTrieNodes += size

+ case len(key) == common.HashLength:

+ trieSize += size

+ default:

+ var accounted bool

+ for _, meta := range [][]byte{databaseVerisionKey, headHeaderKey, headBlockKey, headFastBlockKey, fastTrieProgressKey} {

+ if bytes.Equal(key, meta) {

+ metadata += size

+ accounted = true

+ break

+ }

+ }

+ if !accounted {

+ unaccounted += size

+ }

+ }

+ count += 1

+ if count%1000 == 0 && time.Since(logged) > 8*time.Second {

+ log.Info("Inspecting database", "count", count, "elapsed", common.PrettyDuration(time.Since(start)))

+ logged = time.Now()

+ }

+ }

+ // Inspect append-only file store then.

+ ancients := []*common.StorageSize{&ancientHeaders, &ancientBodies, &ancientReceipts, &ancientHashes, &ancientTds}

+ for i, category := range []string{freezerHeaderTable, freezerBodiesTable, freezerReceiptTable, freezerHashTable, freezerDifficultyTable} {

+ if size, err := db.AncientSize(category); err == nil {

+ *ancients[i] += common.StorageSize(size)

+ total += common.StorageSize(size)

+ }

+ }

+ // Display the database statistic.

+ stats := [][]string{

+ {"Key-Value store", "Headers", headerSize.String()},

+ {"Key-Value store", "Bodies", bodySize.String()},

+ {"Key-Value store", "Receipts", receiptSize.String()},

+ {"Key-Value store", "Difficulties", tdSize.String()},

+ {"Key-Value store", "Block number->hash", numHashPairing.String()},

+ {"Key-Value store", "Block hash->number", hashNumPairing.String()},

+ {"Key-Value store", "Transaction index", txlookupSize.String()},

+ {"Key-Value store", "Bloombit index", bloomBitsSize.String()},

+ {"Key-Value store", "Trie nodes", trieSize.String()},

+ {"Key-Value store", "Trie preimages", preimageSize.String()},

+ {"Key-Value store", "Clique snapshots", cliqueSnapsSize.String()},

+ {"Key-Value store", "Singleton metadata", metadata.String()},

+ {"Ancient store", "Headers", ancientHeaders.String()},

+ {"Ancient store", "Bodies", ancientBodies.String()},

+ {"Ancient store", "Receipts", ancientReceipts.String()},

+ {"Ancient store", "Difficulties", ancientTds.String()},

+ {"Ancient store", "Block number->hash", ancientHashes.String()},

+ {"Light client", "CHT trie nodes", chtTrieNodes.String()},

+ {"Light client", "Bloom trie nodes", bloomTrieNodes.String()},

+ }

+ table := tablewriter.NewWriter(os.Stdout)

+ table.SetHeader([]string{"Database", "Category", "Size"})

+ table.SetFooter([]string{"", "Total", total.String()})

+ table.AppendBulk(stats)

+ table.Render()

+

+ if unaccounted > 0 {

+ log.Error("Database contains unaccounted data", "size", unaccounted)

+ }

+ return nil

+}

+// Copyright 2019 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "errors"

+ "fmt"

+ "math"

+ "os"

+ "path/filepath"

+ "sync/atomic"

+ "time"

+

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/metrics"

+ "github.com/prometheus/tsdb/fileutil"

+)

+

+var (

+ // errUnknownTable is returned if the user attempts to read from a table that is

+ // not tracked by the freezer.

+ errUnknownTable = errors.New("unknown table")

+

+ // errOutOrderInsertion is returned if the user attempts to inject out-of-order

+ // binary blobs into the freezer.

+ errOutOrderInsertion = errors.New("the append operation is out-order")

+

+ // errSymlinkDatadir is returned if the ancient directory specified by user

+ // is a symbolic link.

+ errSymlinkDatadir = errors.New("symbolic link datadir is not supported")

+)

+

+const (

+ // freezerRecheckInterval is the frequency to check the key-value database for

+ // chain progression that might permit new blocks to be frozen into immutable

+ // storage.

+ freezerRecheckInterval = time.Minute

+

+ // freezerBatchLimit is the maximum number of blocks to freeze in one batch

+ // before doing an fsync and deleting it from the key-value store.

+ freezerBatchLimit = 30000

+)

+

+// freezer is an memory mapped append-only database to store immutable chain data

+// into flat files:

+//

+// - The append only nature ensures that disk writes are minimized.

+// - The memory mapping ensures we can max out system memory for caching without

+// reserving it for go-ethereum. This would also reduce the memory requirements

+// of Geth, and thus also GC overhead.

+type freezer struct {

+ // WARNING: The `frozen` field is accessed atomically. On 32 bit platforms, only

+ // 64-bit aligned fields can be atomic. The struct is guaranteed to be so aligned,

+ // so take advantage of that (https://golang.org/pkg/sync/atomic/#pkg-note-BUG).

+ frozen uint64 // Number of blocks already frozen

+

+ tables map[string]*freezerTable // Data tables for storing everything

+ instanceLock fileutil.Releaser // File-system lock to prevent double opens

+}

+

+// newFreezer creates a chain freezer that moves ancient chain data into

+// append-only flat file containers.

+func newFreezer(datadir string, namespace string) (*freezer, error) {

+ // Create the initial freezer object

+ var (

+ readMeter = metrics.NewRegisteredMeter(namespace+"ancient/read", nil)

+ writeMeter = metrics.NewRegisteredMeter(namespace+"ancient/write", nil)

+ sizeCounter = metrics.NewRegisteredCounter(namespace+"ancient/size", nil)

+ )

+ // Ensure the datadir is not a symbolic link if it exists.

+ if info, err := os.Lstat(datadir); !os.IsNotExist(err) {

+ if info.Mode()&os.ModeSymlink != 0 {

+ log.Warn("Symbolic link ancient database is not supported", "path", datadir)

+ return nil, errSymlinkDatadir

+ }

+ }

+ // Leveldb uses LOCK as the filelock filename. To prevent the

+ // name collision, we use FLOCK as the lock name.

+ lock, _, err := fileutil.Flock(filepath.Join(datadir, "FLOCK"))

+ if err != nil {

+ return nil, err

+ }

+ // Open all the supported data tables

+ freezer := &freezer{

+ tables: make(map[string]*freezerTable),

+ instanceLock: lock,

+ }

+ for name, disableSnappy := range freezerNoSnappy {

+ table, err := newTable(datadir, name, readMeter, writeMeter, sizeCounter, disableSnappy)

+ if err != nil {

+ for _, table := range freezer.tables {

+ table.Close()

+ }

+ lock.Release()

+ return nil, err

+ }

+ freezer.tables[name] = table

+ }

+ if err := freezer.repair(); err != nil {

+ for _, table := range freezer.tables {

+ table.Close()

+ }

+ lock.Release()

+ return nil, err

+ }

+ log.Info("Opened ancient database", "database", datadir)

+ return freezer, nil

+}

+

+// Close terminates the chain freezer, unmapping all the data files.

+func (f *freezer) Close() error {

+ var errs []error

+ for _, table := range f.tables {

+ if err := table.Close(); err != nil {

+ errs = append(errs, err)

+ }

+ }

+ if err := f.instanceLock.Release(); err != nil {

+ errs = append(errs, err)

+ }

+ if errs != nil {

+ return fmt.Errorf("%v", errs)

+ }

+ return nil

+}

+

+// HasAncient returns an indicator whether the specified ancient data exists

+// in the freezer.

+func (f *freezer) HasAncient(kind string, number uint64) (bool, error) {

+ if table := f.tables[kind]; table != nil {

+ return table.has(number), nil

+ }

+ return false, nil

+}

+

+// Ancient retrieves an ancient binary blob from the append-only immutable files.

+func (f *freezer) Ancient(kind string, number uint64) ([]byte, error) {

+ if table := f.tables[kind]; table != nil {

+ return table.Retrieve(number)

+ }

+ return nil, errUnknownTable

+}

+

+// Ancients returns the length of the frozen items.

+func (f *freezer) Ancients() (uint64, error) {

+ return atomic.LoadUint64(&f.frozen), nil

+}

+

+// AncientSize returns the ancient size of the specified category.

+func (f *freezer) AncientSize(kind string) (uint64, error) {

+ if table := f.tables[kind]; table != nil {

+ return table.size()

+ }

+ return 0, errUnknownTable

+}

+

+// AppendAncient injects all binary blobs belong to block at the end of the

+// append-only immutable table files.

+//

+// Notably, this function is lock free but kind of thread-safe. All out-of-order

+// injection will be rejected. But if two injections with same number happen at

+// the same time, we can get into the trouble.

+func (f *freezer) AppendAncient(number uint64, hash, header, body, receipts, td []byte) (err error) {

+ // Ensure the binary blobs we are appending is continuous with freezer.

+ if atomic.LoadUint64(&f.frozen) != number {

+ return errOutOrderInsertion

+ }

+ // Rollback all inserted data if any insertion below failed to ensure

+ // the tables won't out of sync.

+ defer func() {

+ if err != nil {

+ rerr := f.repair()

+ if rerr != nil {

+ log.Crit("Failed to repair freezer", "err", rerr)

+ }

+ log.Info("Append ancient failed", "number", number, "err", err)

+ }

+ }()

+ // Inject all the components into the relevant data tables

+ if err := f.tables[freezerHashTable].Append(f.frozen, hash[:]); err != nil {

+ log.Error("Failed to append ancient hash", "number", f.frozen, "hash", hash, "err", err)

+ return err

+ }

+ if err := f.tables[freezerHeaderTable].Append(f.frozen, header); err != nil {

+ log.Error("Failed to append ancient header", "number", f.frozen, "hash", hash, "err", err)

+ return err

+ }

+ if err := f.tables[freezerBodiesTable].Append(f.frozen, body); err != nil {

+ log.Error("Failed to append ancient body", "number", f.frozen, "hash", hash, "err", err)

+ return err

+ }

+ if err := f.tables[freezerReceiptTable].Append(f.frozen, receipts); err != nil {

+ log.Error("Failed to append ancient receipts", "number", f.frozen, "hash", hash, "err", err)

+ return err

+ }

+ if err := f.tables[freezerDifficultyTable].Append(f.frozen, td); err != nil {

+ log.Error("Failed to append ancient difficulty", "number", f.frozen, "hash", hash, "err", err)

+ return err

+ }

+ atomic.AddUint64(&f.frozen, 1) // Only modify atomically

+ return nil

+}

+

+// Truncate discards any recent data above the provided threshold number.

+func (f *freezer) TruncateAncients(items uint64) error {

+ if atomic.LoadUint64(&f.frozen) <= items {

+ return nil

+ }

+ for _, table := range f.tables {

+ if err := table.truncate(items); err != nil {

+ return err

+ }

+ }

+ atomic.StoreUint64(&f.frozen, items)

+ return nil

+}

+

+// sync flushes all data tables to disk.

+func (f *freezer) Sync() error {

+ var errs []error

+ for _, table := range f.tables {

+ if err := table.Sync(); err != nil {

+ errs = append(errs, err)

+ }

+ }

+ if errs != nil {

+ return fmt.Errorf("%v", errs)

+ }

+ return nil

+}

+

+// freeze is a background thread that periodically checks the blockchain for any

+// import progress and moves ancient data from the fast database into the freezer.

+//

+// This functionality is deliberately broken off from block importing to avoid

+// incurring additional data shuffling delays on block propagation.

+func (f *freezer) freeze(db ethdb.KeyValueStore) {

+ nfdb := &nofreezedb{KeyValueStore: db}

+

+ for {

+ // Retrieve the freezing threshold.

+ hash := ReadHeadBlockHash(nfdb)

+ if hash == (common.Hash{}) {

+ log.Debug("Current full block hash unavailable") // new chain, empty database

+ time.Sleep(freezerRecheckInterval)

+ continue

+ }

+ number := ReadHeaderNumber(nfdb, hash)

+ switch {

+ case number == nil:

+ log.Error("Current full block number unavailable", "hash", hash)

+ time.Sleep(freezerRecheckInterval)

+ continue

+

+ case *number < params.ImmutabilityThreshold:

+ log.Debug("Current full block not old enough", "number", *number, "hash", hash, "delay", params.ImmutabilityThreshold)

+ time.Sleep(freezerRecheckInterval)

+ continue

+

+ case *number-params.ImmutabilityThreshold <= f.frozen:

+ log.Debug("Ancient blocks frozen already", "number", *number, "hash", hash, "frozen", f.frozen)

+ time.Sleep(freezerRecheckInterval)

+ continue

+ }

+ head := ReadHeader(nfdb, hash, *number)

+ if head == nil {

+ log.Error("Current full block unavailable", "number", *number, "hash", hash)

+ time.Sleep(freezerRecheckInterval)

+ continue

+ }

+ // Seems we have data ready to be frozen, process in usable batches

+ limit := *number - params.ImmutabilityThreshold

+ if limit-f.frozen > freezerBatchLimit {

+ limit = f.frozen + freezerBatchLimit

+ }

+ var (

+ start = time.Now()

+ first = f.frozen

+ ancients = make([]common.Hash, 0, limit)

+ )

+ for f.frozen < limit {

+ // Retrieves all the components of the canonical block

+ hash := ReadCanonicalHash(nfdb, f.frozen)

+ if hash == (common.Hash{}) {

+ log.Error("Canonical hash missing, can't freeze", "number", f.frozen)

+ break

+ }

+ header := ReadHeaderRLP(nfdb, hash, f.frozen)

+ if len(header) == 0 {

+ log.Error("Block header missing, can't freeze", "number", f.frozen, "hash", hash)

+ break

+ }

+ body := ReadBodyRLP(nfdb, hash, f.frozen)

+ if len(body) == 0 {

+ log.Error("Block body missing, can't freeze", "number", f.frozen, "hash", hash)

+ break

+ }

+ receipts := ReadReceiptsRLP(nfdb, hash, f.frozen)

+ if len(receipts) == 0 {

+ log.Error("Block receipts missing, can't freeze", "number", f.frozen, "hash", hash)

+ break

+ }

+ td := ReadTdRLP(nfdb, hash, f.frozen)

+ if len(td) == 0 {

+ log.Error("Total difficulty missing, can't freeze", "number", f.frozen, "hash", hash)

+ break

+ }

+ log.Trace("Deep froze ancient block", "number", f.frozen, "hash", hash)

+ // Inject all the components into the relevant data tables

+ if err := f.AppendAncient(f.frozen, hash[:], header, body, receipts, td); err != nil {

+ break

+ }

+ ancients = append(ancients, hash)

+ }

+ // Batch of blocks have been frozen, flush them before wiping from leveldb

+ if err := f.Sync(); err != nil {

+ log.Crit("Failed to flush frozen tables", "err", err)

+ }

+ // Wipe out all data from the active database

+ batch := db.NewBatch()

+ for i := 0; i < len(ancients); i++ {

+ // Always keep the genesis block in active database

+ if first+uint64(i) != 0 {

+ DeleteBlockWithoutNumber(batch, ancients[i], first+uint64(i))

+ DeleteCanonicalHash(batch, first+uint64(i))

+ }

+ }

+ if err := batch.Write(); err != nil {

+ log.Crit("Failed to delete frozen canonical blocks", "err", err)

+ }

+ batch.Reset()

+ // Wipe out side chain also.

+ for number := first; number < f.frozen; number++ {

+ // Always keep the genesis block in active database

+ if number != 0 {

+ for _, hash := range ReadAllHashes(db, number) {

+ DeleteBlock(batch, hash, number)

+ }

+ }

+ }

+ if err := batch.Write(); err != nil {

+ log.Crit("Failed to delete frozen side blocks", "err", err)

+ }

+ // Log something friendly for the user

+ context := []interface{}{

+ "blocks", f.frozen - first, "elapsed", common.PrettyDuration(time.Since(start)), "number", f.frozen - 1,

+ }

+ if n := len(ancients); n > 0 {

+ context = append(context, []interface{}{"hash", ancients[n-1]}...)

+ }

+ log.Info("Deep froze chain segment", context...)

+

+ // Avoid database thrashing with tiny writes

+ if f.frozen-first < freezerBatchLimit {

+ time.Sleep(freezerRecheckInterval)

+ }

+ }

+}

+

+// repair truncates all data tables to the same length.

+func (f *freezer) repair() error {

+ min := uint64(math.MaxUint64)

+ for _, table := range f.tables {

+ items := atomic.LoadUint64(&table.items)

+ if min > items {

+ min = items

+ }

+ }

+ for _, table := range f.tables {

+ if err := table.truncate(min); err != nil {

+ return err

+ }

+ }

+ atomic.StoreUint64(&f.frozen, min)

+ return nil

+}

+// Copyright 2019 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "errors"

+ "runtime"

+ "sync/atomic"

+ "time"

+

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/common/prque"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/log"

+)

+

+// InitDatabaseFromFreezer reinitializes an empty database from a previous batch

+// of frozen ancient blocks. The method iterates over all the frozen blocks and

+// injects into the database the block hash->number mappings and the transaction

+// lookup entries.

+func InitDatabaseFromFreezer(db ethdb.Database) error {

+ // If we can't access the freezer or it's empty, abort

+ frozen, err := db.Ancients()

+ if err != nil || frozen == 0 {

+ return err

+ }

+ // Blocks previously frozen, iterate over- and hash them concurrently

+ var (

+ number = ^uint64(0) // -1

+ results = make(chan *types.Block, 4*runtime.NumCPU())

+ )

+ abort := make(chan struct{})

+ defer close(abort)

+

+ for i := 0; i < runtime.NumCPU(); i++ {

+ go func() {

+ for {

+ // Fetch the next task number, terminating if everything's done

+ n := atomic.AddUint64(&number, 1)

+ if n >= frozen {

+ return

+ }

+ // Retrieve the block from the freezer (no need for the hash, we pull by

+ // number from the freezer). If successful, pre-cache the block hash and

+ // the individual transaction hashes for storing into the database.

+ block := ReadBlock(db, common.Hash{}, n)

+ if block != nil {

+ block.Hash()

+ for _, tx := range block.Transactions() {

+ tx.Hash()

+ }

+ }

+ // Feed the block to the aggregator, or abort on interrupt

+ select {

+ case results <- block:

+ case <-abort:

+ return

+ }

+ }

+ }()

+ }

+ // Reassemble the blocks into a contiguous stream and push them out to disk

+ var (

+ queue = prque.New(nil)

+ next = int64(0)

+

+ batch = db.NewBatch()

+ start = time.Now()

+ logged time.Time

+ )

+ for i := uint64(0); i < frozen; i++ {

+ // Retrieve the next result and bail if it's nil

+ block := <-results

+ if block == nil {

+ return errors.New("broken ancient database")

+ }

+ // Push the block into the import queue and process contiguous ranges

+ queue.Push(block, -int64(block.NumberU64()))

+ for !queue.Empty() {

+ // If the next available item is gapped, return

+ if _, priority := queue.Peek(); -priority != next {

+ break

+ }

+ // Next block available, pop it off and index it

+ block = queue.PopItem().(*types.Block)

+ next++

+

+ // Inject hash<->number mapping and txlookup indexes

+ WriteHeaderNumber(batch, block.Hash(), block.NumberU64())

+ WriteTxLookupEntries(batch, block)

+

+ // If enough data was accumulated in memory or we're at the last block, dump to disk

+ if batch.ValueSize() > ethdb.IdealBatchSize || uint64(next) == frozen {

+ if err := batch.Write(); err != nil {

+ return err

+ }

+ batch.Reset()

+ }

+ // If we've spent too much time already, notify the user of what we're doing

+ if time.Since(logged) > 8*time.Second {

+ log.Info("Initializing chain from ancient data", "number", block.Number(), "hash", block.Hash(), "total", frozen-1, "elapsed", common.PrettyDuration(time.Since(start)))

+ logged = time.Now()

+ }

+ }

+ }

+ hash := ReadCanonicalHash(db, frozen-1)

+ WriteHeadHeaderHash(db, hash)

+ WriteHeadFastBlockHash(db, hash)

+

+ log.Info("Initialized chain from ancient data", "number", frozen-1, "hash", hash, "elapsed", common.PrettyDuration(time.Since(start)))

+ return nil

+}

+// Copyright 2019 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "encoding/binary"

+ "errors"

+ "fmt"

+ "io"

+ "os"

+ "path/filepath"

+ "sync"

+ "sync/atomic"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/metrics"

+ "github.com/golang/snappy"

+)

+

+var (

+ // errClosed is returned if an operation attempts to read from or write to the

+ // freezer table after it has already been closed.

+ errClosed = errors.New("closed")

+

+ // errOutOfBounds is returned if the item requested is not contained within the

+ // freezer table.

+ errOutOfBounds = errors.New("out of bounds")

+

+ // errNotSupported is returned if the database doesn't support the required operation.

+ errNotSupported = errors.New("this operation is not supported")

+)

+

+// indexEntry contains the number/id of the file that the data resides in, aswell as the

+// offset within the file to the end of the data

+// In serialized form, the filenum is stored as uint16.

+type indexEntry struct {

+ filenum uint32 // stored as uint16 ( 2 bytes)

+ offset uint32 // stored as uint32 ( 4 bytes)

+}

+

+const indexEntrySize = 6

+

+// unmarshallBinary deserializes binary b into the rawIndex entry.

+func (i *indexEntry) unmarshalBinary(b []byte) error {

+ i.filenum = uint32(binary.BigEndian.Uint16(b[:2]))

+ i.offset = binary.BigEndian.Uint32(b[2:6])

+ return nil

+}

+

+// marshallBinary serializes the rawIndex entry into binary.

+func (i *indexEntry) marshallBinary() []byte {

+ b := make([]byte, indexEntrySize)

+ binary.BigEndian.PutUint16(b[:2], uint16(i.filenum))

+ binary.BigEndian.PutUint32(b[2:6], i.offset)

+ return b

+}

+

+// freezerTable represents a single chained data table within the freezer (e.g. blocks).

+// It consists of a data file (snappy encoded arbitrary data blobs) and an indexEntry

+// file (uncompressed 64 bit indices into the data file).

+type freezerTable struct {

+ // WARNING: The `items` field is accessed atomically. On 32 bit platforms, only

+ // 64-bit aligned fields can be atomic. The struct is guaranteed to be so aligned,

+ // so take advantage of that (https://golang.org/pkg/sync/atomic/#pkg-note-BUG).

+ items uint64 // Number of items stored in the table (including items removed from tail)

+

+ noCompression bool // if true, disables snappy compression. Note: does not work retroactively

+ maxFileSize uint32 // Max file size for data-files

+ name string

+ path string

+

+ head *os.File // File descriptor for the data head of the table

+ files map[uint32]*os.File // open files

+ headId uint32 // number of the currently active head file

+ tailId uint32 // number of the earliest file

+ index *os.File // File descriptor for the indexEntry file of the table

+

+ // In the case that old items are deleted (from the tail), we use itemOffset

+ // to count how many historic items have gone missing.

+ itemOffset uint32 // Offset (number of discarded items)

+

+ headBytes uint32 // Number of bytes written to the head file

+ readMeter metrics.Meter // Meter for measuring the effective amount of data read

+ writeMeter metrics.Meter // Meter for measuring the effective amount of data written

+ sizeCounter metrics.Counter // Counter for tracking the combined size of all freezer tables

+

+ logger log.Logger // Logger with database path and table name ambedded

+ lock sync.RWMutex // Mutex protecting the data file descriptors

+}

+

+// newTable opens a freezer table with default settings - 2G files

+func newTable(path string, name string, readMeter metrics.Meter, writeMeter metrics.Meter, sizeCounter metrics.Counter, disableSnappy bool) (*freezerTable, error) {

+ return newCustomTable(path, name, readMeter, writeMeter, sizeCounter, 2*1000*1000*1000, disableSnappy)

+}

+

+// openFreezerFileForAppend opens a freezer table file and seeks to the end

+func openFreezerFileForAppend(filename string) (*os.File, error) {

+ // Open the file without the O_APPEND flag

+ // because it has differing behaviour during Truncate operations

+ // on different OS's

+ file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0644)

+ if err != nil {

+ return nil, err

+ }

+ // Seek to end for append

+ if _, err = file.Seek(0, io.SeekEnd); err != nil {

+ return nil, err

+ }

+ return file, nil

+}

+

+// openFreezerFileForReadOnly opens a freezer table file for read only access

+func openFreezerFileForReadOnly(filename string) (*os.File, error) {

+ return os.OpenFile(filename, os.O_RDONLY, 0644)

+}

+

+// openFreezerFileTruncated opens a freezer table making sure it is truncated

+func openFreezerFileTruncated(filename string) (*os.File, error) {

+ return os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)

+}

+

+// truncateFreezerFile resizes a freezer table file and seeks to the end

+func truncateFreezerFile(file *os.File, size int64) error {

+ if err := file.Truncate(size); err != nil {

+ return err

+ }

+ // Seek to end for append

+ if _, err := file.Seek(0, io.SeekEnd); err != nil {

+ return err

+ }

+ return nil

+}

+

+// newCustomTable opens a freezer table, creating the data and index files if they are

+// non existent. Both files are truncated to the shortest common length to ensure

+// they don't go out of sync.

+func newCustomTable(path string, name string, readMeter metrics.Meter, writeMeter metrics.Meter, sizeCounter metrics.Counter, maxFilesize uint32, noCompression bool) (*freezerTable, error) {

+ // Ensure the containing directory exists and open the indexEntry file

+ if err := os.MkdirAll(path, 0755); err != nil {

+ return nil, err

+ }

+ var idxName string

+ if noCompression {

+ // Raw idx

+ idxName = fmt.Sprintf("%s.ridx", name)

+ } else {

+ // Compressed idx

+ idxName = fmt.Sprintf("%s.cidx", name)

+ }

+ offsets, err := openFreezerFileForAppend(filepath.Join(path, idxName))

+ if err != nil {

+ return nil, err

+ }

+ // Create the table and repair any past inconsistency

+ tab := &freezerTable{

+ index: offsets,

+ files: make(map[uint32]*os.File),

+ readMeter: readMeter,

+ writeMeter: writeMeter,

+ sizeCounter: sizeCounter,

+ name: name,

+ path: path,

+ logger: log.New("database", path, "table", name),

+ noCompression: noCompression,

+ maxFileSize: maxFilesize,

+ }

+ if err := tab.repair(); err != nil {

+ tab.Close()

+ return nil, err

+ }

+ // Initialize the starting size counter

+ size, err := tab.sizeNolock()

+ if err != nil {

+ tab.Close()

+ return nil, err

+ }

+ tab.sizeCounter.Inc(int64(size))

+

+ return tab, nil

+}

+

+// repair cross checks the head and the index file and truncates them to

+// be in sync with each other after a potential crash / data loss.

+func (t *freezerTable) repair() error {

+ // Create a temporary offset buffer to init files with and read indexEntry into

+ buffer := make([]byte, indexEntrySize)

+

+ // If we've just created the files, initialize the index with the 0 indexEntry

+ stat, err := t.index.Stat()

+ if err != nil {

+ return err

+ }

+ if stat.Size() == 0 {

+ if _, err := t.index.Write(buffer); err != nil {

+ return err

+ }

+ }

+ // Ensure the index is a multiple of indexEntrySize bytes

+ if overflow := stat.Size() % indexEntrySize; overflow != 0 {

+ truncateFreezerFile(t.index, stat.Size()-overflow) // New file can't trigger this path

+ }

+ // Retrieve the file sizes and prepare for truncation

+ if stat, err = t.index.Stat(); err != nil {

+ return err

+ }

+ offsetsSize := stat.Size()

+

+ // Open the head file

+ var (

+ firstIndex indexEntry

+ lastIndex indexEntry

+ contentSize int64

+ contentExp int64

+ )

+ // Read index zero, determine what file is the earliest

+ // and what item offset to use

+ t.index.ReadAt(buffer, 0)

+ firstIndex.unmarshalBinary(buffer)

+

+ t.tailId = firstIndex.offset

+ t.itemOffset = firstIndex.filenum

+

+ t.index.ReadAt(buffer, offsetsSize-indexEntrySize)

+ lastIndex.unmarshalBinary(buffer)

+ t.head, err = t.openFile(lastIndex.filenum, openFreezerFileForAppend)

+ if err != nil {

+ return err

+ }

+ if stat, err = t.head.Stat(); err != nil {

+ return err

+ }

+ contentSize = stat.Size()

+

+ // Keep truncating both files until they come in sync

+ contentExp = int64(lastIndex.offset)

+

+ for contentExp != contentSize {

+ // Truncate the head file to the last offset pointer

+ if contentExp < contentSize {

+ t.logger.Warn("Truncating dangling head", "indexed", common.StorageSize(contentExp), "stored", common.StorageSize(contentSize))

+ if err := truncateFreezerFile(t.head, contentExp); err != nil {

+ return err

+ }

+ contentSize = contentExp

+ }

+ // Truncate the index to point within the head file

+ if contentExp > contentSize {

+ t.logger.Warn("Truncating dangling indexes", "indexed", common.StorageSize(contentExp), "stored", common.StorageSize(contentSize))

+ if err := truncateFreezerFile(t.index, offsetsSize-indexEntrySize); err != nil {

+ return err

+ }

+ offsetsSize -= indexEntrySize

+ t.index.ReadAt(buffer, offsetsSize-indexEntrySize)

+ var newLastIndex indexEntry

+ newLastIndex.unmarshalBinary(buffer)

+ // We might have slipped back into an earlier head-file here

+ if newLastIndex.filenum != lastIndex.filenum {

+ // Release earlier opened file

+ t.releaseFile(lastIndex.filenum)

+ if t.head, err = t.openFile(newLastIndex.filenum, openFreezerFileForAppend); err != nil {

+ return err

+ }

+ if stat, err = t.head.Stat(); err != nil {

+ // TODO, anything more we can do here?

+ // A data file has gone missing...

+ return err

+ }

+ contentSize = stat.Size()

+ }

+ lastIndex = newLastIndex

+ contentExp = int64(lastIndex.offset)

+ }

+ }

+ // Ensure all reparation changes have been written to disk

+ if err := t.index.Sync(); err != nil {

+ return err

+ }

+ if err := t.head.Sync(); err != nil {

+ return err

+ }

+ // Update the item and byte counters and return

+ t.items = uint64(t.itemOffset) + uint64(offsetsSize/indexEntrySize-1) // last indexEntry points to the end of the data file

+ t.headBytes = uint32(contentSize)

+ t.headId = lastIndex.filenum

+

+ // Close opened files and preopen all files

+ if err := t.preopen(); err != nil {

+ return err

+ }

+ t.logger.Debug("Chain freezer table opened", "items", t.items, "size", common.StorageSize(t.headBytes))

+ return nil

+}

+

+// preopen opens all files that the freezer will need. This method should be called from an init-context,

+// since it assumes that it doesn't have to bother with locking

+// The rationale for doing preopen is to not have to do it from within Retrieve, thus not needing to ever

+// obtain a write-lock within Retrieve.

+func (t *freezerTable) preopen() (err error) {

+ // The repair might have already opened (some) files

+ t.releaseFilesAfter(0, false)

+ // Open all except head in RDONLY

+ for i := t.tailId; i < t.headId; i++ {

+ if _, err = t.openFile(i, openFreezerFileForReadOnly); err != nil {

+ return err

+ }

+ }

+ // Open head in read/write

+ t.head, err = t.openFile(t.headId, openFreezerFileForAppend)

+ return err

+}

+

+// truncate discards any recent data above the provided threshold number.

+func (t *freezerTable) truncate(items uint64) error {

+ t.lock.Lock()

+ defer t.lock.Unlock()

+

+ // If our item count is correct, don't do anything

+ if atomic.LoadUint64(&t.items) <= items {

+ return nil

+ }

+ // We need to truncate, save the old size for metrics tracking

+ oldSize, err := t.sizeNolock()

+ if err != nil {

+ return err

+ }

+ // Something's out of sync, truncate the table's offset index

+ t.logger.Warn("Truncating freezer table", "items", t.items, "limit", items)

+ if err := truncateFreezerFile(t.index, int64(items+1)*indexEntrySize); err != nil {

+ return err

+ }

+ // Calculate the new expected size of the data file and truncate it

+ buffer := make([]byte, indexEntrySize)

+ if _, err := t.index.ReadAt(buffer, int64(items*indexEntrySize)); err != nil {

+ return err

+ }

+ var expected indexEntry

+ expected.unmarshalBinary(buffer)

+

+ // We might need to truncate back to older files

+ if expected.filenum != t.headId {

+ // If already open for reading, force-reopen for writing

+ t.releaseFile(expected.filenum)

+ newHead, err := t.openFile(expected.filenum, openFreezerFileForAppend)

+ if err != nil {

+ return err

+ }

+ // Release any files _after the current head -- both the previous head

+ // and any files which may have been opened for reading

+ t.releaseFilesAfter(expected.filenum, true)

+ // Set back the historic head

+ t.head = newHead

+ atomic.StoreUint32(&t.headId, expected.filenum)

+ }

+ if err := truncateFreezerFile(t.head, int64(expected.offset)); err != nil {

+ return err

+ }

+ // All data files truncated, set internal counters and return

+ atomic.StoreUint64(&t.items, items)

+ atomic.StoreUint32(&t.headBytes, expected.offset)

+

+ // Retrieve the new size and update the total size counter

+ newSize, err := t.sizeNolock()

+ if err != nil {

+ return err

+ }

+ t.sizeCounter.Dec(int64(oldSize - newSize))

+

+ return nil

+}

+

+// Close closes all opened files.

+func (t *freezerTable) Close() error {

+ t.lock.Lock()

+ defer t.lock.Unlock()

+

+ var errs []error

+ if err := t.index.Close(); err != nil {

+ errs = append(errs, err)

+ }

+ t.index = nil

+

+ for _, f := range t.files {

+ if err := f.Close(); err != nil {

+ errs = append(errs, err)

+ }

+ }

+ t.head = nil

+

+ if errs != nil {

+ return fmt.Errorf("%v", errs)

+ }

+ return nil

+}

+

+// openFile assumes that the write-lock is held by the caller

+func (t *freezerTable) openFile(num uint32, opener func(string) (*os.File, error)) (f *os.File, err error) {

+ var exist bool

+ if f, exist = t.files[num]; !exist {

+ var name string

+ if t.noCompression {

+ name = fmt.Sprintf("%s.%04d.rdat", t.name, num)

+ } else {

+ name = fmt.Sprintf("%s.%04d.cdat", t.name, num)

+ }

+ f, err = opener(filepath.Join(t.path, name))

+ if err != nil {

+ return nil, err

+ }

+ t.files[num] = f

+ }

+ return f, err

+}

+

+// releaseFile closes a file, and removes it from the open file cache.

+// Assumes that the caller holds the write lock

+func (t *freezerTable) releaseFile(num uint32) {

+ if f, exist := t.files[num]; exist {

+ delete(t.files, num)

+ f.Close()

+ }

+}

+

+// releaseFilesAfter closes all open files with a higher number, and optionally also deletes the files

+func (t *freezerTable) releaseFilesAfter(num uint32, remove bool) {

+ for fnum, f := range t.files {

+ if fnum > num {

+ delete(t.files, fnum)

+ f.Close()

+ if remove {

+ os.Remove(f.Name())

+ }

+ }

+ }

+}

+

+// Append injects a binary blob at the end of the freezer table. The item number

+// is a precautionary parameter to ensure data correctness, but the table will

+// reject already existing data.

+//

+// Note, this method will *not* flush any data to disk so be sure to explicitly

+// fsync before irreversibly deleting data from the database.

+func (t *freezerTable) Append(item uint64, blob []byte) error {

+ // Read lock prevents competition with truncate

+ t.lock.RLock()

+ // Ensure the table is still accessible

+ if t.index == nil || t.head == nil {

+ t.lock.RUnlock()

+ return errClosed

+ }

+ // Ensure only the next item can be written, nothing else

+ if atomic.LoadUint64(&t.items) != item {

+ t.lock.RUnlock()

+ return fmt.Errorf("appending unexpected item: want %d, have %d", t.items, item)

+ }

+ // Encode the blob and write it into the data file

+ if !t.noCompression {

+ blob = snappy.Encode(nil, blob)

+ }

+ bLen := uint32(len(blob))

+ if t.headBytes+bLen < bLen ||

+ t.headBytes+bLen > t.maxFileSize {

+ // we need a new file, writing would overflow

+ t.lock.RUnlock()

+ t.lock.Lock()

+ nextID := atomic.LoadUint32(&t.headId) + 1

+ // We open the next file in truncated mode -- if this file already

+ // exists, we need to start over from scratch on it

+ newHead, err := t.openFile(nextID, openFreezerFileTruncated)

+ if err != nil {

+ t.lock.Unlock()

+ return err

+ }

+ // Close old file, and reopen in RDONLY mode

+ t.releaseFile(t.headId)

+ t.openFile(t.headId, openFreezerFileForReadOnly)

+

+ // Swap out the current head

+ t.head = newHead

+ atomic.StoreUint32(&t.headBytes, 0)

+ atomic.StoreUint32(&t.headId, nextID)

+ t.lock.Unlock()

+ t.lock.RLock()

+ }

+

+ defer t.lock.RUnlock()

+ if _, err := t.head.Write(blob); err != nil {

+ return err

+ }

+ newOffset := atomic.AddUint32(&t.headBytes, bLen)

+ idx := indexEntry{

+ filenum: atomic.LoadUint32(&t.headId),

+ offset: newOffset,

+ }

+ // Write indexEntry

+ t.index.Write(idx.marshallBinary())

+

+ t.writeMeter.Mark(int64(bLen + indexEntrySize))

+ t.sizeCounter.Inc(int64(bLen + indexEntrySize))

+

+ atomic.AddUint64(&t.items, 1)

+ return nil

+}

+

+// getBounds returns the indexes for the item

+// returns start, end, filenumber and error

+func (t *freezerTable) getBounds(item uint64) (uint32, uint32, uint32, error) {

+ var startIdx, endIdx indexEntry

+ buffer := make([]byte, indexEntrySize)

+ if _, err := t.index.ReadAt(buffer, int64(item*indexEntrySize)); err != nil {

+ return 0, 0, 0, err

+ }

+ startIdx.unmarshalBinary(buffer)

+ if _, err := t.index.ReadAt(buffer, int64((item+1)*indexEntrySize)); err != nil {

+ return 0, 0, 0, err

+ }

+ endIdx.unmarshalBinary(buffer)

+ if startIdx.filenum != endIdx.filenum {

+ // If a piece of data 'crosses' a data-file,

+ // it's actually in one piece on the second data-file.

+ // We return a zero-indexEntry for the second file as start

+ return 0, endIdx.offset, endIdx.filenum, nil

+ }

+ return startIdx.offset, endIdx.offset, endIdx.filenum, nil

+}

+

+// Retrieve looks up the data offset of an item with the given number and retrieves

+// the raw binary blob from the data file.

+func (t *freezerTable) Retrieve(item uint64) ([]byte, error) {

+ // Ensure the table and the item is accessible

+ if t.index == nil || t.head == nil {

+ return nil, errClosed

+ }

+ if atomic.LoadUint64(&t.items) <= item {

+ return nil, errOutOfBounds

+ }

+ // Ensure the item was not deleted from the tail either

+ offset := atomic.LoadUint32(&t.itemOffset)

+ if uint64(offset) > item {

+ return nil, errOutOfBounds

+ }

+ t.lock.RLock()

+ startOffset, endOffset, filenum, err := t.getBounds(item - uint64(offset))

+ if err != nil {

+ t.lock.RUnlock()

+ return nil, err

+ }

+ dataFile, exist := t.files[filenum]

+ if !exist {

+ t.lock.RUnlock()

+ return nil, fmt.Errorf("missing data file %d", filenum)

+ }

+ // Retrieve the data itself, decompress and return

+ blob := make([]byte, endOffset-startOffset)

+ if _, err := dataFile.ReadAt(blob, int64(startOffset)); err != nil {

+ t.lock.RUnlock()

+ return nil, err

+ }

+ t.lock.RUnlock()

+ t.readMeter.Mark(int64(len(blob) + 2*indexEntrySize))

+

+ if t.noCompression {

+ return blob, nil

+ }

+ return snappy.Decode(nil, blob)

+}

+

+// has returns an indicator whether the specified number data

+// exists in the freezer table.

+func (t *freezerTable) has(number uint64) bool {

+ return atomic.LoadUint64(&t.items) > number

+}

+

+// size returns the total data size in the freezer table.

+func (t *freezerTable) size() (uint64, error) {

+ t.lock.RLock()

+ defer t.lock.RUnlock()

+

+ return t.sizeNolock()

+}

+

+// sizeNolock returns the total data size in the freezer table without obtaining

+// the mutex first.

+func (t *freezerTable) sizeNolock() (uint64, error) {

+ stat, err := t.index.Stat()

+ if err != nil {

+ return 0, err

+ }

+ total := uint64(t.maxFileSize)*uint64(t.headId-t.tailId) + uint64(t.headBytes) + uint64(stat.Size())

+ return total, nil

+}

+

+// Sync pushes any pending data from memory out to disk. This is an expensive

+// operation, so use it with care.

+func (t *freezerTable) Sync() error {

+ if err := t.index.Sync(); err != nil {

+ return err

+ }

+ return t.head.Sync()

+}

+

+// printIndex is a debug print utility function for testing

+func (t *freezerTable) printIndex() {

+ buf := make([]byte, indexEntrySize)

+

+ fmt.Printf("|-----------------|\n")

+ fmt.Printf("| fileno | offset |\n")

+ fmt.Printf("|--------+--------|\n")

+

+ for i := uint64(0); ; i++ {

+ if _, err := t.index.ReadAt(buf, int64(i*indexEntrySize)); err != nil {

+ break

+ }

+ var entry indexEntry

+ entry.unmarshalBinary(buf)

+ fmt.Printf("| %03d | %03d | \n", entry.filenum, entry.offset)

+ if i > 100 {

+ fmt.Printf(" ... \n")

+ break

+ }

+ }

+ fmt.Printf("|-----------------|\n")

+}

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+// Package rawdb contains a collection of low level database accessors.

+package rawdb

+

+import (

+ "encoding/binary"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/metrics"

+)

+

+// The fields below define the low level database schema prefixing.

+var (

+ // databaseVerisionKey tracks the current database version.

+ databaseVerisionKey = []byte("DatabaseVersion")

+

+ // headHeaderKey tracks the latest known header's hash.

+ headHeaderKey = []byte("LastHeader")

+

+ // headBlockKey tracks the latest known full block's hash.

+ headBlockKey = []byte("LastBlock")

+

+ // headFastBlockKey tracks the latest known incomplete block's hash during fast sync.

+ headFastBlockKey = []byte("LastFast")

+

+ // fastTrieProgressKey tracks the number of trie entries imported during fast sync.

+ fastTrieProgressKey = []byte("TrieSync")

+

+ // Data item prefixes (use single byte to avoid mixing data types, avoid `i`, used for indexes).

+ headerPrefix = []byte("h") // headerPrefix + num (uint64 big endian) + hash -> header

+ headerTDSuffix = []byte("t") // headerPrefix + num (uint64 big endian) + hash + headerTDSuffix -> td

+ headerHashSuffix = []byte("n") // headerPrefix + num (uint64 big endian) + headerHashSuffix -> hash

+ headerNumberPrefix = []byte("H") // headerNumberPrefix + hash -> num (uint64 big endian)

+

+ blockBodyPrefix = []byte("b") // blockBodyPrefix + num (uint64 big endian) + hash -> block body

+ blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts

+

+ txLookupPrefix = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata

+ bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits

+

+ preimagePrefix = []byte("secure-key-") // preimagePrefix + hash -> preimage

+ configPrefix = []byte("ethereum-config-") // config prefix for the db

+

+ // Chain index prefixes (use `i` + single byte to avoid mixing data types).

+ BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress

+

+ preimageCounter = metrics.NewRegisteredCounter("db/preimage/total", nil)

+ preimageHitCounter = metrics.NewRegisteredCounter("db/preimage/hits", nil)

+)

+

+const (

+ // freezerHeaderTable indicates the name of the freezer header table.

+ freezerHeaderTable = "headers"

+

+ // freezerHashTable indicates the name of the freezer canonical hash table.

+ freezerHashTable = "hashes"

+

+ // freezerBodiesTable indicates the name of the freezer block body table.

+ freezerBodiesTable = "bodies"

+

+ // freezerReceiptTable indicates the name of the freezer receipts table.

+ freezerReceiptTable = "receipts"

+

+ // freezerDifficultyTable indicates the name of the freezer total difficulty table.

+ freezerDifficultyTable = "diffs"

+)

+

+// freezerNoSnappy configures whether compression is disabled for the ancient-tables.

+// Hashes and difficulties don't compress well.

+var freezerNoSnappy = map[string]bool{

+ freezerHeaderTable: false,

+ freezerHashTable: true,

+ freezerBodiesTable: false,

+ freezerReceiptTable: false,

+ freezerDifficultyTable: true,

+}

+

+// LegacyTxLookupEntry is the legacy TxLookupEntry definition with some unnecessary

+// fields.

+type LegacyTxLookupEntry struct {

+ BlockHash common.Hash

+ BlockIndex uint64

+ Index uint64

+}

+

+// encodeBlockNumber encodes a block number as big endian uint64

+func encodeBlockNumber(number uint64) []byte {

+ enc := make([]byte, 8)

+ binary.BigEndian.PutUint64(enc, number)

+ return enc

+}

+

+// headerKeyPrefix = headerPrefix + num (uint64 big endian)

+func headerKeyPrefix(number uint64) []byte {

+ return append(headerPrefix, encodeBlockNumber(number)...)

+}

+

+// headerKey = headerPrefix + num (uint64 big endian) + hash

+func headerKey(number uint64, hash common.Hash) []byte {

+ return append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...)

+}

+

+// headerTDKey = headerPrefix + num (uint64 big endian) + hash + headerTDSuffix

+func headerTDKey(number uint64, hash common.Hash) []byte {

+ return append(headerKey(number, hash), headerTDSuffix...)

+}

+

+// headerHashKey = headerPrefix + num (uint64 big endian) + headerHashSuffix

+func headerHashKey(number uint64) []byte {

+ return append(append(headerPrefix, encodeBlockNumber(number)...), headerHashSuffix...)

+}

+

+// headerNumberKey = headerNumberPrefix + hash

+func headerNumberKey(hash common.Hash) []byte {

+ return append(headerNumberPrefix, hash.Bytes()...)

+}

+

+// blockBodyKey = blockBodyPrefix + num (uint64 big endian) + hash

+func blockBodyKey(number uint64, hash common.Hash) []byte {

+ return append(append(blockBodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...)

+}

+

+// blockReceiptsKey = blockReceiptsPrefix + num (uint64 big endian) + hash

+func blockReceiptsKey(number uint64, hash common.Hash) []byte {

+ return append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...)

+}

+

+// txLookupKey = txLookupPrefix + hash

+func txLookupKey(hash common.Hash) []byte {

+ return append(txLookupPrefix, hash.Bytes()...)

+}

+

+// bloomBitsKey = bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash

+func bloomBitsKey(bit uint, section uint64, hash common.Hash) []byte {

+ key := append(append(bloomBitsPrefix, make([]byte, 10)...), hash.Bytes()...)

+

+ binary.BigEndian.PutUint16(key[1:], uint16(bit))

+ binary.BigEndian.PutUint64(key[3:], section)

+

+ return key

+}

+

+// preimageKey = preimagePrefix + hash

+func preimageKey(hash common.Hash) []byte {

+ return append(preimagePrefix, hash.Bytes()...)

+}

+

+// configKey = configPrefix + hash

+func configKey(hash common.Hash) []byte {

+ return append(configPrefix, hash.Bytes()...)

+}

+// Copyright 2018 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package rawdb

+

+import (

+ "github.com/ava-labs/go-ethereum/ethdb"

+)

+

+// table is a wrapper around a database that prefixes each key access with a pre-

+// configured string.

+type table struct {

+ db ethdb.Database

+ prefix string

+}

+

+// NewTable returns a database object that prefixes all keys with a given string.

+func NewTable(db ethdb.Database, prefix string) ethdb.Database {

+ return &table{

+ db: db,

+ prefix: prefix,

+ }

+}

+

+// Close is a noop to implement the Database interface.

+func (t *table) Close() error {

+ return nil

+}

+

+// Has retrieves if a prefixed version of a key is present in the database.

+func (t *table) Has(key []byte) (bool, error) {

+ return t.db.Has(append([]byte(t.prefix), key...))

+}

+

+// Get retrieves the given prefixed key if it's present in the database.

+func (t *table) Get(key []byte) ([]byte, error) {

+ return t.db.Get(append([]byte(t.prefix), key...))

+}

+

+// HasAncient is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) HasAncient(kind string, number uint64) (bool, error) {

+ return t.db.HasAncient(kind, number)

+}

+

+// Ancient is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) Ancient(kind string, number uint64) ([]byte, error) {

+ return t.db.Ancient(kind, number)

+}

+

+// Ancients is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) Ancients() (uint64, error) {

+ return t.db.Ancients()

+}

+

+// AncientSize is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) AncientSize(kind string) (uint64, error) {

+ return t.db.AncientSize(kind)

+}

+

+// AppendAncient is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) AppendAncient(number uint64, hash, header, body, receipts, td []byte) error {

+ return t.db.AppendAncient(number, hash, header, body, receipts, td)

+}

+

+// TruncateAncients is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) TruncateAncients(items uint64) error {

+ return t.db.TruncateAncients(items)

+}

+

+// Sync is a noop passthrough that just forwards the request to the underlying

+// database.

+func (t *table) Sync() error {

+ return t.db.Sync()

+}

+

+// Put inserts the given value into the database at a prefixed version of the

+// provided key.

+func (t *table) Put(key []byte, value []byte) error {

+ return t.db.Put(append([]byte(t.prefix), key...), value)

+}

+

+// Delete removes the given prefixed key from the database.

+func (t *table) Delete(key []byte) error {

+ return t.db.Delete(append([]byte(t.prefix), key...))

+}

+

+// NewIterator creates a binary-alphabetical iterator over the entire keyspace

+// contained within the database.

+func (t *table) NewIterator() ethdb.Iterator {

+ return t.NewIteratorWithPrefix(nil)

+}

+

+// NewIteratorWithStart creates a binary-alphabetical iterator over a subset of

+// database content starting at a particular initial key (or after, if it does

+// not exist).

+func (t *table) NewIteratorWithStart(start []byte) ethdb.Iterator {

+ return t.db.NewIteratorWithStart(start)

+}

+

+// NewIteratorWithPrefix creates a binary-alphabetical iterator over a subset

+// of database content with a particular key prefix.

+func (t *table) NewIteratorWithPrefix(prefix []byte) ethdb.Iterator {

+ return t.db.NewIteratorWithPrefix(append([]byte(t.prefix), prefix...))

+}

+

+// Stat returns a particular internal stat of the database.

+func (t *table) Stat(property string) (string, error) {

+ return t.db.Stat(property)

+}

+

+// Compact flattens the underlying data store for the given key range. In essence,

+// deleted and overwritten versions are discarded, and the data is rearranged to

+// reduce the cost of operations needed to access them.

+//

+// A nil start is treated as a key before all keys in the data store; a nil limit

+// is treated as a key after all keys in the data store. If both is nil then it

+// will compact entire data store.

+func (t *table) Compact(start []byte, limit []byte) error {

+ // If no start was specified, use the table prefix as the first value

+ if start == nil {

+ start = []byte(t.prefix)

+ }

+ // If no limit was specified, use the first element not matching the prefix

+ // as the limit

+ if limit == nil {

+ limit = []byte(t.prefix)

+ for i := len(limit) - 1; i >= 0; i-- {

+ // Bump the current character, stopping if it doesn't overflow

+ limit[i]++

+ if limit[i] > 0 {

+ break

+ }

+ // Character overflown, proceed to the next or nil if the last

+ if i == 0 {

+ limit = nil

+ }

+ }

+ }

+ // Range correctly calculated based on table prefix, delegate down

+ return t.db.Compact(start, limit)

+}

+

+// NewBatch creates a write-only database that buffers changes to its host db

+// until a final write is called, each operation prefixing all keys with the

+// pre-configured string.

+func (t *table) NewBatch() ethdb.Batch {

+ return &tableBatch{t.db.NewBatch(), t.prefix}

+}

+

+// tableBatch is a wrapper around a database batch that prefixes each key access

+// with a pre-configured string.

+type tableBatch struct {

+ batch ethdb.Batch

+ prefix string

+}

+

+// Put inserts the given value into the batch for later committing.

+func (b *tableBatch) Put(key, value []byte) error {

+ return b.batch.Put(append([]byte(b.prefix), key...), value)

+}

+

+// Delete inserts the a key removal into the batch for later committing.

+func (b *tableBatch) Delete(key []byte) error {

+ return b.batch.Delete(append([]byte(b.prefix), key...))

+}

+

+// ValueSize retrieves the amount of data queued up for writing.

+func (b *tableBatch) ValueSize() int {

+ return b.batch.ValueSize()

+}

+

+// Write flushes any accumulated data to disk.

+func (b *tableBatch) Write() error {

+ return b.batch.Write()

+}

+

+// Reset resets the batch for reuse.

+func (b *tableBatch) Reset() {

+ b.batch.Reset()

+}

+

+// Replay replays the batch contents.

+func (b *tableBatch) Replay(w ethdb.KeyValueWriter) error {

+ return b.batch.Replay(w)

+}

+// Copyright 2017 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "fmt"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/trie"

+ lru "github.com/hashicorp/golang-lru"

+)

+

+const (

+ // Number of codehash->size associations to keep.

+ codeSizeCacheSize = 100000

+)

+

+// Database wraps access to tries and contract code.

+type Database interface {

+ // OpenTrie opens the main account trie.

+ OpenTrie(root common.Hash) (Trie, error)

+

+ // OpenStorageTrie opens the storage trie of an account.

+ OpenStorageTrie(addrHash, root common.Hash) (Trie, error)

+

+ // CopyTrie returns an independent copy of the given trie.

+ CopyTrie(Trie) Trie

+

+ // ContractCode retrieves a particular contract's code.

+ ContractCode(addrHash, codeHash common.Hash) ([]byte, error)

+

+ // ContractCodeSize retrieves a particular contracts code's size.

+ ContractCodeSize(addrHash, codeHash common.Hash) (int, error)

+

+ // TrieDB retrieves the low level trie database used for data storage.

+ TrieDB() *trie.Database

+}

+

+// Trie is a Ethereum Merkle Patricia trie.

+type Trie interface {

+ // GetKey returns the sha3 preimage of a hashed key that was previously used

+ // to store a value.

+ //

+ // TODO(fjl): remove this when SecureTrie is removed

+ GetKey([]byte) []byte

+

+ // TryGet returns the value for key stored in the trie. The value bytes must

+ // not be modified by the caller. If a node was not found in the database, a

+ // trie.MissingNodeError is returned.

+ TryGet(key []byte) ([]byte, error)

+

+ // TryUpdate associates key with value in the trie. If value has length zero, any

+ // existing value is deleted from the trie. The value bytes must not be modified

+ // by the caller while they are stored in the trie. If a node was not found in the

+ // database, a trie.MissingNodeError is returned.

+ TryUpdate(key, value []byte) error

+

+ // TryDelete removes any existing value for key from the trie. If a node was not

+ // found in the database, a trie.MissingNodeError is returned.

+ TryDelete(key []byte) error

+

+ // Hash returns the root hash of the trie. It does not write to the database and

+ // can be used even if the trie doesn't have one.

+ Hash() common.Hash

+

+ // Commit writes all nodes to the trie's memory database, tracking the internal

+ // and external (for account tries) references.

+ Commit(onleaf trie.LeafCallback) (common.Hash, error)

+

+ // NodeIterator returns an iterator that returns nodes of the trie. Iteration

+ // starts at the key after the given start key.

+ NodeIterator(startKey []byte) trie.NodeIterator

+

+ // Prove constructs a Merkle proof for key. The result contains all encoded nodes

+ // on the path to the value at key. The value itself is also included in the last

+ // node and can be retrieved by verifying the proof.

+ //

+ // If the trie does not contain a value for key, the returned proof contains all

+ // nodes of the longest existing prefix of the key (at least the root), ending

+ // with the node that proves the absence of the key.

+ Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error

+}

+

+// NewDatabase creates a backing store for state. The returned database is safe for

+// concurrent use, but does not retain any recent trie nodes in memory. To keep some

+// historical state in memory, use the NewDatabaseWithCache constructor.

+func NewDatabase(db ethdb.Database) Database {

+ return NewDatabaseWithCache(db, 0)

+}

+

+// NewDatabaseWithCache creates a backing store for state. The returned database

+// is safe for concurrent use and retains a lot of collapsed RLP trie nodes in a

+// large memory cache.

+func NewDatabaseWithCache(db ethdb.Database, cache int) Database {

+ csc, _ := lru.New(codeSizeCacheSize)

+ return &cachingDB{

+ db: trie.NewDatabaseWithCache(db, cache),

+ codeSizeCache: csc,

+ }

+}

+

+type cachingDB struct {

+ db *trie.Database

+ codeSizeCache *lru.Cache

+}

+

+// OpenTrie opens the main account trie at a specific root hash.

+func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {

+ return trie.NewSecure(root, db.db)

+}

+

+// OpenStorageTrie opens the storage trie of an account.

+func (db *cachingDB) OpenStorageTrie(addrHash, root common.Hash) (Trie, error) {

+ return trie.NewSecure(root, db.db)

+}

+

+// CopyTrie returns an independent copy of the given trie.

+func (db *cachingDB) CopyTrie(t Trie) Trie {

+ switch t := t.(type) {

+ case *trie.SecureTrie:

+ return t.Copy()

+ default:

+ panic(fmt.Errorf("unknown trie type %T", t))

+ }

+}

+

+// ContractCode retrieves a particular contract's code.

+func (db *cachingDB) ContractCode(addrHash, codeHash common.Hash) ([]byte, error) {

+ code, err := db.db.Node(codeHash)

+ if err == nil {

+ db.codeSizeCache.Add(codeHash, len(code))

+ }

+ return code, err

+}

+

+// ContractCodeSize retrieves a particular contracts code's size.

+func (db *cachingDB) ContractCodeSize(addrHash, codeHash common.Hash) (int, error) {

+ if cached, ok := db.codeSizeCache.Get(codeHash); ok {

+ return cached.(int), nil

+ }

+ code, err := db.ContractCode(addrHash, codeHash)

+ return len(code), err

+}

+

+// TrieDB retrieves any intermediate trie-node caching layer.

+func (db *cachingDB) TrieDB() *trie.Database {

+ return db.db

+}

+// Copyright 2014 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "encoding/json"

+ "fmt"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/common/hexutil"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/rlp"

+ "github.com/ava-labs/go-ethereum/trie"

+)

+

+// DumpAccount represents an account in the state

+type DumpAccount struct {

+ Balance string `json:"balance"`

+ Nonce uint64 `json:"nonce"`

+ Root string `json:"root"`

+ CodeHash string `json:"codeHash"`

+ Code string `json:"code,omitempty"`

+ Storage map[common.Hash]string `json:"storage,omitempty"`

+ Address *common.Address `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode

+ SecureKey hexutil.Bytes `json:"key,omitempty"` // If we don't have address, we can output the key

+

+}

+

+// Dump represents the full dump in a collected format, as one large map

+type Dump struct {

+ Root string `json:"root"`

+ Accounts map[common.Address]DumpAccount `json:"accounts"`

+}

+

+// iterativeDump is a 'collector'-implementation which dump output line-by-line iteratively

+type iterativeDump json.Encoder

+

+// Collector interface which the state trie calls during iteration

+type collector interface {

+ onRoot(common.Hash)

+ onAccount(common.Address, DumpAccount)

+}

+

+func (self *Dump) onRoot(root common.Hash) {

+ self.Root = fmt.Sprintf("%x", root)

+}

+

+func (self *Dump) onAccount(addr common.Address, account DumpAccount) {

+ self.Accounts[addr] = account

+}

+

+func (self iterativeDump) onAccount(addr common.Address, account DumpAccount) {

+ dumpAccount := &DumpAccount{

+ Balance: account.Balance,

+ Nonce: account.Nonce,

+ Root: account.Root,

+ CodeHash: account.CodeHash,

+ Code: account.Code,

+ Storage: account.Storage,

+ SecureKey: account.SecureKey,

+ Address: nil,

+ }

+ if addr != (common.Address{}) {

+ dumpAccount.Address = &addr

+ }

+ (*json.Encoder)(&self).Encode(dumpAccount)

+}

+func (self iterativeDump) onRoot(root common.Hash) {

+ (*json.Encoder)(&self).Encode(struct {

+ Root common.Hash `json:"root"`

+ }{root})

+}

+

+func (self *StateDB) dump(c collector, excludeCode, excludeStorage, excludeMissingPreimages bool) {

+ emptyAddress := (common.Address{})

+ missingPreimages := 0

+ c.onRoot(self.trie.Hash())

+ it := trie.NewIterator(self.trie.NodeIterator(nil))

+ for it.Next() {

+ var data Account

+ if err := rlp.DecodeBytes(it.Value, &data); err != nil {

+ panic(err)

+ }

+ addr := common.BytesToAddress(self.trie.GetKey(it.Key))

+ obj := newObject(nil, addr, data)

+ account := DumpAccount{

+ Balance: data.Balance.String(),

+ Nonce: data.Nonce,

+ Root: common.Bytes2Hex(data.Root[:]),

+ CodeHash: common.Bytes2Hex(data.CodeHash),

+ }

+ if emptyAddress == addr {

+ // Preimage missing

+ missingPreimages++

+ if excludeMissingPreimages {

+ continue

+ }

+ account.SecureKey = it.Key

+ }

+ if !excludeCode {

+ account.Code = common.Bytes2Hex(obj.Code(self.db))

+ }

+ if !excludeStorage {

+ account.Storage = make(map[common.Hash]string)

+ storageIt := trie.NewIterator(obj.getTrie(self.db).NodeIterator(nil))

+ for storageIt.Next() {

+ _, content, _, err := rlp.Split(storageIt.Value)

+ if err != nil {

+ log.Error("Failed to decode the value returned by iterator", "error", err)

+ continue

+ }

+ account.Storage[common.BytesToHash(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(content)

+ }

+ }

+ c.onAccount(addr, account)

+ }

+ if missingPreimages > 0 {

+ log.Warn("Dump incomplete due to missing preimages", "missing", missingPreimages)

+ }

+}

+

+// RawDump returns the entire state an a single large object

+func (self *StateDB) RawDump(excludeCode, excludeStorage, excludeMissingPreimages bool) Dump {

+ dump := &Dump{

+ Accounts: make(map[common.Address]DumpAccount),

+ }

+ self.dump(dump, excludeCode, excludeStorage, excludeMissingPreimages)

+ return *dump

+}

+

+// Dump returns a JSON string representing the entire state as a single json-object

+func (self *StateDB) Dump(excludeCode, excludeStorage, excludeMissingPreimages bool) []byte {

+ dump := self.RawDump(excludeCode, excludeStorage, excludeMissingPreimages)

+ json, err := json.MarshalIndent(dump, "", " ")

+ if err != nil {

+ fmt.Println("dump err", err)

+ }

+ return json

+}

+

+// IterativeDump dumps out accounts as json-objects, delimited by linebreaks on stdout

+func (self *StateDB) IterativeDump(excludeCode, excludeStorage, excludeMissingPreimages bool, output *json.Encoder) {

+ self.dump(iterativeDump(*output), excludeCode, excludeStorage, excludeMissingPreimages)

+}

+// Copyright 2015 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "bytes"

+ "fmt"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/rlp"

+ "github.com/ava-labs/go-ethereum/trie"

+)

+

+// NodeIterator is an iterator to traverse the entire state trie post-order,

+// including all of the contract code and contract state tries.

+type NodeIterator struct {

+ state *StateDB // State being iterated

+

+ stateIt trie.NodeIterator // Primary iterator for the global state trie

+ dataIt trie.NodeIterator // Secondary iterator for the data trie of a contract

+

+ accountHash common.Hash // Hash of the node containing the account

+ codeHash common.Hash // Hash of the contract source code

+ code []byte // Source code associated with a contract

+

+ Hash common.Hash // Hash of the current entry being iterated (nil if not standalone)

+ Parent common.Hash // Hash of the first full ancestor node (nil if current is the root)

+

+ Error error // Failure set in case of an internal error in the iterator

+}

+

+// NewNodeIterator creates an post-order state node iterator.

+func NewNodeIterator(state *StateDB) *NodeIterator {

+ return &NodeIterator{

+ state: state,

+ }

+}

+

+// Next moves the iterator to the next node, returning whether there are any

+// further nodes. In case of an internal error this method returns false and

+// sets the Error field to the encountered failure.

+func (it *NodeIterator) Next() bool {

+ // If the iterator failed previously, don't do anything

+ if it.Error != nil {

+ return false

+ }

+ // Otherwise step forward with the iterator and report any errors

+ if err := it.step(); err != nil {

+ it.Error = err

+ return false

+ }

+ return it.retrieve()

+}

+

+// step moves the iterator to the next entry of the state trie.

+func (it *NodeIterator) step() error {

+ // Abort if we reached the end of the iteration

+ if it.state == nil {

+ return nil

+ }

+ // Initialize the iterator if we've just started

+ if it.stateIt == nil {

+ it.stateIt = it.state.trie.NodeIterator(nil)

+ }

+ // If we had data nodes previously, we surely have at least state nodes

+ if it.dataIt != nil {

+ if cont := it.dataIt.Next(true); !cont {

+ if it.dataIt.Error() != nil {

+ return it.dataIt.Error()

+ }

+ it.dataIt = nil

+ }

+ return nil

+ }

+ // If we had source code previously, discard that

+ if it.code != nil {

+ it.code = nil

+ return nil

+ }

+ // Step to the next state trie node, terminating if we're out of nodes

+ if cont := it.stateIt.Next(true); !cont {

+ if it.stateIt.Error() != nil {

+ return it.stateIt.Error()

+ }

+ it.state, it.stateIt = nil, nil

+ return nil

+ }

+ // If the state trie node is an internal entry, leave as is

+ if !it.stateIt.Leaf() {

+ return nil

+ }

+ // Otherwise we've reached an account node, initiate data iteration

+ var account Account

+ if err := rlp.Decode(bytes.NewReader(it.stateIt.LeafBlob()), &account); err != nil {

+ return err

+ }

+ dataTrie, err := it.state.db.OpenStorageTrie(common.BytesToHash(it.stateIt.LeafKey()), account.Root)

+ if err != nil {

+ return err

+ }

+ it.dataIt = dataTrie.NodeIterator(nil)

+ if !it.dataIt.Next(true) {

+ it.dataIt = nil

+ }

+ if !bytes.Equal(account.CodeHash, emptyCodeHash) {

+ it.codeHash = common.BytesToHash(account.CodeHash)

+ addrHash := common.BytesToHash(it.stateIt.LeafKey())

+ it.code, err = it.state.db.ContractCode(addrHash, common.BytesToHash(account.CodeHash))

+ if err != nil {

+ return fmt.Errorf("code %x: %v", account.CodeHash, err)

+ }

+ }

+ it.accountHash = it.stateIt.Parent()

+ return nil

+}

+

+// retrieve pulls and caches the current state entry the iterator is traversing.

+// The method returns whether there are any more data left for inspection.

+func (it *NodeIterator) retrieve() bool {

+ // Clear out any previously set values

+ it.Hash = common.Hash{}

+

+ // If the iteration's done, return no available data

+ if it.state == nil {

+ return false

+ }

+ // Otherwise retrieve the current entry

+ switch {

+ case it.dataIt != nil:

+ it.Hash, it.Parent = it.dataIt.Hash(), it.dataIt.Parent()

+ if it.Parent == (common.Hash{}) {

+ it.Parent = it.accountHash

+ }

+ case it.code != nil:

+ it.Hash, it.Parent = it.codeHash, it.accountHash

+ case it.stateIt != nil:

+ it.Hash, it.Parent = it.stateIt.Hash(), it.stateIt.Parent()

+ }

+ return true

+}

+// Copyright 2016 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "math/big"

+

+ "github.com/ava-labs/go-ethereum/common"

+)

+

+// journalEntry is a modification entry in the state change journal that can be

+// reverted on demand.

+type journalEntry interface {

+ // revert undoes the changes introduced by this journal entry.

+ revert(*StateDB)

+

+ // dirtied returns the Ethereum address modified by this journal entry.

+ dirtied() *common.Address

+}

+

+// journal contains the list of state modifications applied since the last state

+// commit. These are tracked to be able to be reverted in case of an execution

+// exception or revertal request.

+type journal struct {

+ entries []journalEntry // Current changes tracked by the journal

+ dirties map[common.Address]int // Dirty accounts and the number of changes

+}

+

+// newJournal create a new initialized journal.

+func newJournal() *journal {

+ return &journal{

+ dirties: make(map[common.Address]int),

+ }

+}

+

+// append inserts a new modification entry to the end of the change journal.

+func (j *journal) append(entry journalEntry) {

+ j.entries = append(j.entries, entry)

+ if addr := entry.dirtied(); addr != nil {

+ j.dirties[*addr]++

+ }

+}

+

+// revert undoes a batch of journalled modifications along with any reverted

+// dirty handling too.

+func (j *journal) revert(statedb *StateDB, snapshot int) {

+ for i := len(j.entries) - 1; i >= snapshot; i-- {

+ // Undo the changes made by the operation

+ j.entries[i].revert(statedb)

+

+ // Drop any dirty tracking induced by the change

+ if addr := j.entries[i].dirtied(); addr != nil {

+ if j.dirties[*addr]--; j.dirties[*addr] == 0 {

+ delete(j.dirties, *addr)

+ }

+ }

+ }

+ j.entries = j.entries[:snapshot]

+}

+

+// dirty explicitly sets an address to dirty, even if the change entries would

+// otherwise suggest it as clean. This method is an ugly hack to handle the RIPEMD

+// precompile consensus exception.

+func (j *journal) dirty(addr common.Address) {

+ j.dirties[addr]++

+}

+

+// length returns the current number of entries in the journal.

+func (j *journal) length() int {

+ return len(j.entries)

+}

+

+type (

+ // Changes to the account trie.

+ createObjectChange struct {

+ account *common.Address

+ }

+ resetObjectChange struct {

+ prev *stateObject

+ }

+ suicideChange struct {

+ account *common.Address

+ prev bool // whether account had already suicided

+ prevbalance *big.Int

+ }

+

+ // Changes to individual accounts.

+ balanceChange struct {

+ account *common.Address

+ prev *big.Int

+ }

+ multiCoinEnable struct {

+ account *common.Address

+ }

+ nonceChange struct {

+ account *common.Address

+ prev uint64

+ }

+ storageChange struct {

+ account *common.Address

+ key, prevalue common.Hash

+ }

+ codeChange struct {

+ account *common.Address

+ prevcode, prevhash []byte

+ }

+

+ // Changes to other state values.

+ refundChange struct {

+ prev uint64

+ }

+ addLogChange struct {

+ txhash common.Hash

+ }

+ addPreimageChange struct {

+ hash common.Hash

+ }

+ touchChange struct {

+ account *common.Address

+ prev bool

+ prevDirty bool

+ }

+)

+

+func (ch createObjectChange) revert(s *StateDB) {

+ delete(s.stateObjects, *ch.account)

+ delete(s.stateObjectsDirty, *ch.account)

+}

+

+func (ch createObjectChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch resetObjectChange) revert(s *StateDB) {

+ s.setStateObject(ch.prev)

+}

+

+func (ch resetObjectChange) dirtied() *common.Address {

+ return nil

+}

+

+func (ch suicideChange) revert(s *StateDB) {

+ obj := s.getStateObject(*ch.account)

+ if obj != nil {

+ obj.suicided = ch.prev

+ obj.setBalance(ch.prevbalance)

+ }

+}

+

+func (ch suicideChange) dirtied() *common.Address {

+ return ch.account

+}

+

+var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")

+

+func (ch touchChange) revert(s *StateDB) {

+}

+

+func (ch touchChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch balanceChange) revert(s *StateDB) {

+ s.getStateObject(*ch.account).setBalance(ch.prev)

+}

+

+func (ch balanceChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch multiCoinEnable) revert(s *StateDB) {

+ s.getStateObject(*ch.account).data.IsMultiCoin = false

+}

+

+func (ch multiCoinEnable) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch nonceChange) revert(s *StateDB) {

+ s.getStateObject(*ch.account).setNonce(ch.prev)

+}

+

+func (ch nonceChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch codeChange) revert(s *StateDB) {

+ s.getStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode)

+}

+

+func (ch codeChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch storageChange) revert(s *StateDB) {

+ s.getStateObject(*ch.account).setState(ch.key, ch.prevalue)

+}

+

+func (ch storageChange) dirtied() *common.Address {

+ return ch.account

+}

+

+func (ch refundChange) revert(s *StateDB) {

+ s.refund = ch.prev

+}

+

+func (ch refundChange) dirtied() *common.Address {

+ return nil

+}

+

+func (ch addLogChange) revert(s *StateDB) {

+ logs := s.logs[ch.txhash]

+ if len(logs) == 1 {

+ delete(s.logs, ch.txhash)

+ } else {

+ s.logs[ch.txhash] = logs[:len(logs)-1]

+ }

+ s.logSize--

+}

+

+func (ch addLogChange) dirtied() *common.Address {

+ return nil

+}

+

+func (ch addPreimageChange) revert(s *StateDB) {

+ delete(s.preimages, ch.hash)

+}

+

+func (ch addPreimageChange) dirtied() *common.Address {

+ return nil

+}

+// Copyright 2014 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "bytes"

+ "fmt"

+ "io"

+ "math/big"

+ "time"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/crypto"

+ "github.com/ava-labs/go-ethereum/metrics"

+ "github.com/ava-labs/go-ethereum/rlp"

+)

+

+var emptyCodeHash = crypto.Keccak256(nil)

+

+type Code []byte

+

+func (c Code) String() string {

+ return string(c) //strings.Join(Disassemble(c), " ")

+}

+

+type Storage map[common.Hash]common.Hash

+

+func (s Storage) String() (str string) {

+ for key, value := range s {

+ str += fmt.Sprintf("%X : %X\n", key, value)

+ }

+

+ return

+}

+

+func (s Storage) Copy() Storage {

+ cpy := make(Storage)

+ for key, value := range s {

+ cpy[key] = value

+ }

+

+ return cpy

+}

+

+// stateObject represents an Ethereum account which is being modified.

+//

+// The usage pattern is as follows:

+// First you need to obtain a state object.

+// Account values can be accessed and modified through the object.

+// Finally, call CommitTrie to write the modified storage trie into a database.

+type stateObject struct {

+ address common.Address

+ addrHash common.Hash // hash of ethereum address of the account

+ data Account

+ db *StateDB

+

+ // DB error.

+ // State objects are used by the consensus core and VM which are

+ // unable to deal with database-level errors. Any error that occurs

+ // during a database read is memoized here and will eventually be returned

+ // by StateDB.Commit.

+ dbErr error

+

+ // Write caches.

+ trie Trie // storage trie, which becomes non-nil on first access

+ code Code // contract bytecode, which gets set when code is loaded

+

+ originStorage Storage // Storage cache of original entries to dedup rewrites

+ dirtyStorage Storage // Storage entries that need to be flushed to disk

+ fakeStorage Storage // Fake storage which constructed by caller for debugging purpose.

+

+ // Cache flags.

+ // When an object is marked suicided it will be delete from the trie

+ // during the "update" phase of the state transition.

+ dirtyCode bool // true if the code was updated

+ suicided bool

+ deleted bool

+}

+

+// empty returns whether the account is considered empty.

+func (s *stateObject) empty() bool {

+ return s.data.Nonce == 0 && s.data.Balance.Sign() == 0 && bytes.Equal(s.data.CodeHash, emptyCodeHash)

+}

+

+// Account is the Ethereum consensus representation of accounts.

+// These objects are stored in the main account trie.

+type Account struct {

+ Nonce uint64

+ Balance *big.Int

+ Root common.Hash // merkle root of the storage trie

+ CodeHash []byte

+ IsMultiCoin bool

+}

+

+// newObject creates a state object.

+func newObject(db *StateDB, address common.Address, data Account) *stateObject {

+ if data.Balance == nil {

+ data.Balance = new(big.Int)

+ }

+ if data.CodeHash == nil {

+ data.CodeHash = emptyCodeHash

+ }

+ return &stateObject{

+ db: db,

+ address: address,

+ addrHash: crypto.Keccak256Hash(address[:]),

+ data: data,

+ originStorage: make(Storage),

+ dirtyStorage: make(Storage),

+ }

+}

+

+// EncodeRLP implements rlp.Encoder.

+func (s *stateObject) EncodeRLP(w io.Writer) error {

+ return rlp.Encode(w, s.data)

+}

+

+// setError remembers the first non-nil error it is called with.

+func (s *stateObject) setError(err error) {

+ if s.dbErr == nil {

+ s.dbErr = err

+ }

+}

+

+func (s *stateObject) markSuicided() {

+ s.suicided = true

+}

+

+func (s *stateObject) touch() {

+ s.db.journal.append(touchChange{

+ account: &s.address,

+ })

+ if s.address == ripemd {

+ // Explicitly put it in the dirty-cache, which is otherwise generated from

+ // flattened journals.

+ s.db.journal.dirty(s.address)

+ }

+}

+

+func (s *stateObject) getTrie(db Database) Trie {

+ if s.trie == nil {

+ var err error

+ s.trie, err = db.OpenStorageTrie(s.addrHash, s.data.Root)

+ if err != nil {

+ s.trie, _ = db.OpenStorageTrie(s.addrHash, common.Hash{})

+ s.setError(fmt.Errorf("can't create storage trie: %v", err))

+ }

+ }

+ return s.trie

+}

+

+// GetState retrieves a value from the account storage trie.

+func (s *stateObject) GetState(db Database, key common.Hash) common.Hash {

+ // If the fake storage is set, only lookup the state here(in the debugging mode)

+ if s.fakeStorage != nil {

+ return s.fakeStorage[key]

+ }

+ // If we have a dirty value for this state entry, return it

+ value, dirty := s.dirtyStorage[key]

+ if dirty {

+ return value

+ }

+ // Otherwise return the entry's original value

+ return s.GetCommittedState(db, key)

+}

+

+// GetCommittedState retrieves a value from the committed account storage trie.

+func (s *stateObject) GetCommittedState(db Database, key common.Hash) common.Hash {

+ // If the fake storage is set, only lookup the state here(in the debugging mode)

+ if s.fakeStorage != nil {

+ return s.fakeStorage[key]

+ }

+ // If we have the original value cached, return that

+ value, cached := s.originStorage[key]

+ if cached {

+ return value

+ }

+ // Track the amount of time wasted on reading the storage trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.StorageReads += time.Since(start) }(time.Now())

+ }

+ // Otherwise load the value from the database

+ enc, err := s.getTrie(db).TryGet(key[:])

+ if err != nil {

+ s.setError(err)

+ return common.Hash{}

+ }

+ if len(enc) > 0 {

+ _, content, _, err := rlp.Split(enc)

+ if err != nil {

+ s.setError(err)

+ }

+ value.SetBytes(content)

+ }

+ s.originStorage[key] = value

+ return value

+}

+

+// SetState updates a value in account storage.

+func (s *stateObject) SetState(db Database, key, value common.Hash) {

+ // If the fake storage is set, put the temporary state update here.

+ if s.fakeStorage != nil {

+ s.fakeStorage[key] = value

+ return

+ }

+ // If the new value is the same as old, don't set

+ prev := s.GetState(db, key)

+ if prev == value {

+ return

+ }

+ // New value is different, update and journal the change

+ s.db.journal.append(storageChange{

+ account: &s.address,

+ key: key,

+ prevalue: prev,

+ })

+ s.setState(key, value)

+}

+

+// SetStorage replaces the entire state storage with the given one.

+//

+// After this function is called, all original state will be ignored and state

+// lookup only happens in the fake state storage.

+//

+// Note this function should only be used for debugging purpose.

+func (s *stateObject) SetStorage(storage map[common.Hash]common.Hash) {

+ // Allocate fake storage if it's nil.

+ if s.fakeStorage == nil {

+ s.fakeStorage = make(Storage)

+ }

+ for key, value := range storage {

+ s.fakeStorage[key] = value

+ }

+ // Don't bother journal since this function should only be used for

+ // debugging and the `fake` storage won't be committed to database.

+}

+

+func (s *stateObject) setState(key, value common.Hash) {

+ s.dirtyStorage[key] = value

+}

+

+// updateTrie writes cached storage modifications into the object's storage trie.

+func (s *stateObject) updateTrie(db Database) Trie {

+ // Track the amount of time wasted on updating the storge trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.StorageUpdates += time.Since(start) }(time.Now())

+ }

+ // Update all the dirty slots in the trie

+ tr := s.getTrie(db)

+ for key, value := range s.dirtyStorage {

+ delete(s.dirtyStorage, key)

+

+ // Skip noop changes, persist actual changes

+ if value == s.originStorage[key] {

+ continue

+ }

+ s.originStorage[key] = value

+

+ if (value == common.Hash{}) {

+ s.setError(tr.TryDelete(key[:]))

+ continue

+ }

+ // Encoding []byte cannot fail, ok to ignore the error.

+ v, _ := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00"))

+ s.setError(tr.TryUpdate(key[:], v))

+ }

+ return tr

+}

+

+// UpdateRoot sets the trie root to the current root hash of

+func (s *stateObject) updateRoot(db Database) {

+ s.updateTrie(db)

+

+ // Track the amount of time wasted on hashing the storge trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.StorageHashes += time.Since(start) }(time.Now())

+ }

+ s.data.Root = s.trie.Hash()

+}

+

+// CommitTrie the storage trie of the object to db.

+// This updates the trie root.

+func (s *stateObject) CommitTrie(db Database) error {

+ s.updateTrie(db)

+ if s.dbErr != nil {

+ return s.dbErr

+ }

+ // Track the amount of time wasted on committing the storge trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.StorageCommits += time.Since(start) }(time.Now())

+ }

+ root, err := s.trie.Commit(nil)

+ if err == nil {

+ s.data.Root = root

+ }

+ return err

+}

+

+// AddBalance removes amount from c's balance.

+// It is used to add funds to the destination account of a transfer.

+func (s *stateObject) AddBalance(amount *big.Int) {

+ // EIP158: We must check emptiness for the objects such that the account

+ // clearing (0,0,0 objects) can take effect.

+ if amount.Sign() == 0 {

+ if s.empty() {

+ s.touch()

+ }

+

+ return

+ }

+ s.SetBalance(new(big.Int).Add(s.Balance(), amount))

+}

+

+// SubBalance removes amount from c's balance.

+// It is used to remove funds from the origin account of a transfer.

+func (s *stateObject) SubBalance(amount *big.Int) {

+ if amount.Sign() == 0 {

+ return

+ }

+ s.SetBalance(new(big.Int).Sub(s.Balance(), amount))

+}

+

+func (s *stateObject) SetBalance(amount *big.Int) {

+ s.db.journal.append(balanceChange{

+ account: &s.address,

+ prev: new(big.Int).Set(s.data.Balance),

+ })

+ s.setBalance(amount)

+}

+

+// AddBalance removes amount from c's balance.

+// It is used to add funds to the destination account of a transfer.

+func (s *stateObject) AddBalanceMultiCoin(coinID common.Hash, amount *big.Int, db Database) {

+ if amount.Sign() == 0 {

+ if s.empty() {

+ s.touch()

+ }

+

+ return

+ }

+ s.SetBalanceMultiCoin(coinID, new(big.Int).Add(s.BalanceMultiCoin(coinID, db), amount), db)

+}

+

+// SubBalance removes amount from c's balance.

+// It is used to remove funds from the origin account of a transfer.

+func (s *stateObject) SubBalanceMultiCoin(coinID common.Hash, amount *big.Int, db Database) {

+ if amount.Sign() == 0 {

+ return

+ }

+ s.SetBalanceMultiCoin(coinID, new(big.Int).Sub(s.BalanceMultiCoin(coinID, db), amount), db)

+}

+

+func (s *stateObject) SetBalanceMultiCoin(coinID common.Hash, amount *big.Int, db Database) {

+ NormalizeCoinID(&coinID)

+ s.SetState(db, coinID, common.BigToHash(amount))

+}

+

+func (s *stateObject) setBalance(amount *big.Int) {

+ s.data.Balance = amount

+}

+

+func (s *stateObject) enableMultiCoin() {

+ s.data.IsMultiCoin = true

+}

+

+// Return the gas back to the origin. Used by the Virtual machine or Closures

+func (s *stateObject) ReturnGas(gas *big.Int) {}

+

+func (s *stateObject) deepCopy(db *StateDB) *stateObject {

+ stateObject := newObject(db, s.address, s.data)

+ if s.trie != nil {

+ stateObject.trie = db.db.CopyTrie(s.trie)

+ }

+ stateObject.code = s.code

+ stateObject.dirtyStorage = s.dirtyStorage.Copy()

+ stateObject.originStorage = s.originStorage.Copy()

+ stateObject.suicided = s.suicided

+ stateObject.dirtyCode = s.dirtyCode

+ stateObject.deleted = s.deleted

+ return stateObject

+}

+

+//

+// Attribute accessors

+//

+

+// Returns the address of the contract/account

+func (s *stateObject) Address() common.Address {

+ return s.address

+}

+

+// Code returns the contract code associated with this object, if any.

+func (s *stateObject) Code(db Database) []byte {

+ if s.code != nil {

+ return s.code

+ }

+ if bytes.Equal(s.CodeHash(), emptyCodeHash) {

+ return nil

+ }

+ code, err := db.ContractCode(s.addrHash, common.BytesToHash(s.CodeHash()))

+ if err != nil {

+ s.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err))

+ }

+ s.code = code

+ return code

+}

+

+func (s *stateObject) SetCode(codeHash common.Hash, code []byte) {

+ prevcode := s.Code(s.db.db)

+ s.db.journal.append(codeChange{

+ account: &s.address,

+ prevhash: s.CodeHash(),

+ prevcode: prevcode,

+ })

+ s.setCode(codeHash, code)

+}

+

+func (s *stateObject) setCode(codeHash common.Hash, code []byte) {

+ s.code = code

+ s.data.CodeHash = codeHash[:]

+ s.dirtyCode = true

+}

+

+func (s *stateObject) SetNonce(nonce uint64) {

+ s.db.journal.append(nonceChange{

+ account: &s.address,

+ prev: s.data.Nonce,

+ })

+ s.setNonce(nonce)

+}

+

+func (s *stateObject) setNonce(nonce uint64) {

+ s.data.Nonce = nonce

+}

+

+func (s *stateObject) CodeHash() []byte {

+ return s.data.CodeHash

+}

+

+func (s *stateObject) Balance() *big.Int {

+ return s.data.Balance

+}

+

+func IsMultiCoinKey(key common.Hash) bool {

+ return key[0]&0x01 == 0x01

+}

+

+func NormalizeCoinID(coinID *common.Hash) {

+ coinID[0] |= 0x01

+}

+

+func NormalizeStateKey(key *common.Hash) {

+ key[0] &= 0xfe

+}

+

+func (s *stateObject) BalanceMultiCoin(coinID common.Hash, db Database) *big.Int {

+ NormalizeCoinID(&coinID)

+ return s.GetState(db, coinID).Big()

+}

+

+func (s *stateObject) EnableMultiCoin() bool {

+ if s.data.IsMultiCoin {

+ return false

+ }

+ s.db.journal.append(multiCoinEnable{

+ account: &s.address,

+ })

+ s.enableMultiCoin()

+ return true

+}

+

+func (s *stateObject) IsMultiCoin() bool {

+ return s.data.IsMultiCoin

+}

+

+func (s *stateObject) Nonce() uint64 {

+ return s.data.Nonce

+}

+

+// Never called, but must be present to allow stateObject to be used

+// as a vm.Account interface that also satisfies the vm.ContractRef

+// interface. Interfaces are awesome.

+func (s *stateObject) Value() *big.Int {

+ panic("Value on stateObject should never be called")

+}

+// Copyright 2014 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+// Package state provides a caching layer atop the Ethereum state trie.

+package state

+

+import (

+ "errors"

+ "fmt"

+ "math/big"

+ "sort"

+ "time"

+

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/crypto"

+ "github.com/ava-labs/go-ethereum/log"

+ "github.com/ava-labs/go-ethereum/metrics"

+ "github.com/ava-labs/go-ethereum/rlp"

+ "github.com/ava-labs/go-ethereum/trie"

+)

+

+type revision struct {

+ id int

+ journalIndex int

+}

+

+var (

+ // emptyRoot is the known root hash of an empty trie.

+ emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")

+ zeroRoot = common.HexToHash("0000000000000000000000000000000000000000000000000000000000000000")

+

+ // emptyCode is the known hash of the empty EVM bytecode.

+ emptyCode = crypto.Keccak256Hash(nil)

+)

+

+type proofList [][]byte

+

+func (n *proofList) Put(key []byte, value []byte) error {

+ *n = append(*n, value)

+ return nil

+}

+

+func (n *proofList) Delete(key []byte) error {

+ panic("not supported")

+}

+

+// StateDBs within the ethereum protocol are used to store anything

+// within the merkle trie. StateDBs take care of caching and storing

+// nested states. It's the general query interface to retrieve:

+// * Contracts

+// * Accounts

+type StateDB struct {

+ db Database

+ trie Trie

+

+ // This map holds 'live' objects, which will get modified while processing a state transition.

+ stateObjects map[common.Address]*stateObject

+ stateObjectsDirty map[common.Address]struct{}

+

+ // DB error.

+ // State objects are used by the consensus core and VM which are

+ // unable to deal with database-level errors. Any error that occurs

+ // during a database read is memoized here and will eventually be returned

+ // by StateDB.Commit.

+ dbErr error

+

+ // The refund counter, also used by state transitioning.

+ refund uint64

+

+ thash, bhash common.Hash

+ txIndex int

+ logs map[common.Hash][]*types.Log

+ logSize uint

+

+ preimages map[common.Hash][]byte

+

+ // Journal of state modifications. This is the backbone of

+ // Snapshot and RevertToSnapshot.

+ journal *journal

+ validRevisions []revision

+ nextRevisionId int

+

+ // Measurements gathered during execution for debugging purposes

+ AccountReads time.Duration

+ AccountHashes time.Duration

+ AccountUpdates time.Duration

+ AccountCommits time.Duration

+ StorageReads time.Duration

+ StorageHashes time.Duration

+ StorageUpdates time.Duration

+ StorageCommits time.Duration

+}

+

+// Create a new state from a given trie.

+func New(root common.Hash, db Database) (*StateDB, error) {

+ tr, err := db.OpenTrie(root)

+ if err != nil {

+ return nil, err

+ }

+ return &StateDB{

+ db: db,

+ trie: tr,

+ stateObjects: make(map[common.Address]*stateObject),

+ stateObjectsDirty: make(map[common.Address]struct{}),

+ logs: make(map[common.Hash][]*types.Log),

+ preimages: make(map[common.Hash][]byte),

+ journal: newJournal(),

+ }, nil

+}

+

+// setError remembers the first non-nil error it is called with.

+func (self *StateDB) setError(err error) {

+ if self.dbErr == nil {

+ self.dbErr = err

+ }

+}

+

+func (self *StateDB) Error() error {

+ return self.dbErr

+}

+

+// Reset clears out all ephemeral state objects from the state db, but keeps

+// the underlying state trie to avoid reloading data for the next operations.

+func (self *StateDB) Reset(root common.Hash) error {

+ tr, err := self.db.OpenTrie(root)

+ if err != nil {

+ return err

+ }

+ self.trie = tr

+ self.stateObjects = make(map[common.Address]*stateObject)

+ self.stateObjectsDirty = make(map[common.Address]struct{})

+ self.thash = common.Hash{}

+ self.bhash = common.Hash{}

+ self.txIndex = 0

+ self.logs = make(map[common.Hash][]*types.Log)

+ self.logSize = 0

+ self.preimages = make(map[common.Hash][]byte)

+ self.clearJournalAndRefund()

+ return nil

+}

+

+func (self *StateDB) AddLog(log *types.Log) {

+ self.journal.append(addLogChange{txhash: self.thash})

+

+ log.TxHash = self.thash

+ log.BlockHash = self.bhash

+ log.TxIndex = uint(self.txIndex)

+ log.Index = self.logSize

+ self.logs[self.thash] = append(self.logs[self.thash], log)

+ self.logSize++

+}

+

+func (self *StateDB) GetLogs(hash common.Hash) []*types.Log {

+ return self.logs[hash]

+}

+

+func (self *StateDB) Logs() []*types.Log {

+ var logs []*types.Log

+ for _, lgs := range self.logs {

+ logs = append(logs, lgs...)

+ }

+ return logs

+}

+

+// AddPreimage records a SHA3 preimage seen by the VM.

+func (self *StateDB) AddPreimage(hash common.Hash, preimage []byte) {

+ if _, ok := self.preimages[hash]; !ok {

+ self.journal.append(addPreimageChange{hash: hash})

+ pi := make([]byte, len(preimage))

+ copy(pi, preimage)

+ self.preimages[hash] = pi

+ }

+}

+

+// Preimages returns a list of SHA3 preimages that have been submitted.

+func (self *StateDB) Preimages() map[common.Hash][]byte {

+ return self.preimages

+}

+

+// AddRefund adds gas to the refund counter

+func (self *StateDB) AddRefund(gas uint64) {

+ self.journal.append(refundChange{prev: self.refund})

+ self.refund += gas

+}

+

+// SubRefund removes gas from the refund counter.

+// This method will panic if the refund counter goes below zero

+func (self *StateDB) SubRefund(gas uint64) {

+ self.journal.append(refundChange{prev: self.refund})

+ if gas > self.refund {

+ panic("Refund counter below zero")

+ }

+ self.refund -= gas

+}

+

+// Exist reports whether the given account address exists in the state.

+// Notably this also returns true for suicided accounts.

+func (self *StateDB) Exist(addr common.Address) bool {

+ return self.getStateObject(addr) != nil

+}

+

+// Empty returns whether the state object is either non-existent

+// or empty according to the EIP161 specification (balance = nonce = code = 0)

+func (self *StateDB) Empty(addr common.Address) bool {

+ so := self.getStateObject(addr)

+ return so == nil || so.empty()

+}

+

+// Retrieve the balance from the given address or 0 if object not found

+func (self *StateDB) GetBalance(addr common.Address) *big.Int {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.Balance()

+ }

+ return common.Big0

+}

+

+// Retrieve the balance from the given address or 0 if object not found

+func (self *StateDB) GetBalanceMultiCoin(addr common.Address, coinID common.Hash) *big.Int {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.BalanceMultiCoin(coinID, self.db)

+ }

+ return common.Big0

+}

+

+func (self *StateDB) EnableMultiCoin(addr common.Address) error {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject.data.Root != emptyRoot && stateObject.data.Root != zeroRoot {

+ return errors.New("not a fresh account")

+ }

+ if !stateObject.EnableMultiCoin() {

+ return errors.New("multi-coin mode already enabled")

+ }

+ return nil

+}

+

+func (self *StateDB) ForceEnableMultiCoin(addr common.Address) {

+ stateObject := self.GetOrNewStateObject(addr)

+ stateObject.EnableMultiCoin()

+}

+

+func (self *StateDB) IsMultiCoin(addr common.Address) bool {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.IsMultiCoin()

+ }

+ return false

+}

+

+func (self *StateDB) GetNonce(addr common.Address) uint64 {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.Nonce()

+ }

+

+ return 0

+}

+

+// TxIndex returns the current transaction index set by Prepare.

+func (self *StateDB) TxIndex() int {

+ return self.txIndex

+}

+

+// BlockHash returns the current block hash set by Prepare.

+func (self *StateDB) BlockHash() common.Hash {

+ return self.bhash

+}

+

+func (self *StateDB) GetCode(addr common.Address) []byte {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.Code(self.db)

+ }

+ return nil

+}

+

+func (self *StateDB) GetCodeSize(addr common.Address) int {

+ stateObject := self.getStateObject(addr)

+ if stateObject == nil {

+ return 0

+ }

+ if stateObject.code != nil {

+ return len(stateObject.code)

+ }

+ size, err := self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash()))

+ if err != nil {

+ self.setError(err)

+ }

+ return size

+}

+

+func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {

+ stateObject := self.getStateObject(addr)

+ if stateObject == nil {

+ return common.Hash{}

+ }

+ return common.BytesToHash(stateObject.CodeHash())

+}

+

+// GetState retrieves a value from the given account's storage trie.

+func (self *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.GetState(self.db, hash)

+ }

+ return common.Hash{}

+}

+

+// GetProof returns the MerkleProof for a given Account

+func (self *StateDB) GetProof(a common.Address) ([][]byte, error) {

+ var proof proofList

+ err := self.trie.Prove(crypto.Keccak256(a.Bytes()), 0, &proof)

+ return [][]byte(proof), err

+}

+

+// GetProof returns the StorageProof for given key

+func (self *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {

+ var proof proofList

+ trie := self.StorageTrie(a)

+ if trie == nil {

+ return proof, errors.New("storage trie for requested address does not exist")

+ }

+ err := trie.Prove(crypto.Keccak256(key.Bytes()), 0, &proof)

+ return [][]byte(proof), err

+}

+

+// GetCommittedState retrieves a value from the given account's committed storage trie.

+func (self *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.GetCommittedState(self.db, hash)

+ }

+ return common.Hash{}

+}

+

+// Database retrieves the low level database supporting the lower level trie ops.

+func (self *StateDB) Database() Database {

+ return self.db

+}

+

+// StorageTrie returns the storage trie of an account.

+// The return value is a copy and is nil for non-existent accounts.

+func (self *StateDB) StorageTrie(addr common.Address) Trie {

+ stateObject := self.getStateObject(addr)

+ if stateObject == nil {

+ return nil

+ }

+ cpy := stateObject.deepCopy(self)

+ return cpy.updateTrie(self.db)

+}

+

+func (self *StateDB) HasSuicided(addr common.Address) bool {

+ stateObject := self.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.suicided

+ }

+ return false

+}

+

+/*

+ * SETTERS

+ */

+

+// AddBalance adds amount to the account associated with addr.

+func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.AddBalance(amount)

+ }

+}

+

+// SubBalance subtracts amount from the account associated with addr.

+func (self *StateDB) SubBalance(addr common.Address, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SubBalance(amount)

+ }

+}

+

+func (self *StateDB) SetBalance(addr common.Address, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SetBalance(amount)

+ }

+}

+

+// AddBalance adds amount to the account associated with addr.

+func (self *StateDB) AddBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.AddBalanceMultiCoin(coinID, amount, self.db)

+ }

+}

+

+// SubBalance subtracts amount from the account associated with addr.

+func (self *StateDB) SubBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SubBalanceMultiCoin(coinID, amount, self.db)

+ }

+}

+

+func (self *StateDB) SetBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SetBalanceMultiCoin(coinID, amount, self.db)

+ }

+}

+

+func (self *StateDB) SetNonce(addr common.Address, nonce uint64) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SetNonce(nonce)

+ }

+}

+

+func (self *StateDB) SetCode(addr common.Address, code []byte) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SetCode(crypto.Keccak256Hash(code), code)

+ }

+}

+

+func (self *StateDB) SetState(addr common.Address, key, value common.Hash) (res error) {

+ res = nil

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ if stateObject.data.IsMultiCoin {

+ NormalizeStateKey(&key)

+ }

+ stateObject.SetState(self.db, key, value)

+ }

+ return

+}

+

+// SetStorage replaces the entire storage for the specified account with given

+// storage. This function should only be used for debugging.

+func (self *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {

+ stateObject := self.GetOrNewStateObject(addr)

+ if stateObject != nil {

+ stateObject.SetStorage(storage)

+ }

+}

+

+// Suicide marks the given account as suicided.

+// This clears the account balance.

+//

+// The account's state object is still available until the state is committed,

+// getStateObject will return a non-nil account after Suicide.

+func (self *StateDB) Suicide(addr common.Address) bool {

+ stateObject := self.getStateObject(addr)

+ if stateObject == nil {

+ return false

+ }

+ self.journal.append(suicideChange{

+ account: &addr,

+ prev: stateObject.suicided,

+ prevbalance: new(big.Int).Set(stateObject.Balance()),

+ })

+ stateObject.markSuicided()

+ stateObject.data.Balance = new(big.Int)

+

+ return true

+}

+

+//

+// Setting, updating & deleting state object methods.

+//

+

+// updateStateObject writes the given object to the trie.

+func (s *StateDB) updateStateObject(stateObject *stateObject) {

+ // Track the amount of time wasted on updating the account from the trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())

+ }

+ // Encode the account and update the account trie

+ addr := stateObject.Address()

+

+ data, err := rlp.EncodeToBytes(stateObject)

+ if err != nil {

+ panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err))

+ }

+ s.setError(s.trie.TryUpdate(addr[:], data))

+}

+

+// deleteStateObject removes the given object from the state trie.

+func (s *StateDB) deleteStateObject(stateObject *stateObject) {

+ // Track the amount of time wasted on deleting the account from the trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())

+ }

+ // Delete the account from the trie

+ stateObject.deleted = true

+

+ addr := stateObject.Address()

+ s.setError(s.trie.TryDelete(addr[:]))

+}

+

+// Retrieve a state object given by the address. Returns nil if not found.

+func (s *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) {

+ // Prefer live objects

+ if obj := s.stateObjects[addr]; obj != nil {

+ if obj.deleted {

+ return nil

+ }

+ return obj

+ }

+ // Track the amount of time wasted on loading the object from the database

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())

+ }

+ // Load the object from the database

+ enc, err := s.trie.TryGet(addr[:])

+ if len(enc) == 0 {

+ s.setError(err)

+ return nil

+ }

+ var data Account

+ if err := rlp.DecodeBytes(enc, &data); err != nil {

+ log.Error("Failed to decode state object", "addr", addr, "err", err)

+ return nil

+ }

+ // Insert into the live set

+ obj := newObject(s, addr, data)

+ s.setStateObject(obj)

+ return obj

+}

+

+func (self *StateDB) setStateObject(object *stateObject) {

+ self.stateObjects[object.Address()] = object

+}

+

+// Retrieve a state object or create a new state object if nil.

+func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {

+ stateObject := self.getStateObject(addr)

+ if stateObject == nil || stateObject.deleted {

+ stateObject, _ = self.createObject(addr)

+ }

+ return stateObject

+}

+

+// createObject creates a new state object. If there is an existing account with

+// the given address, it is overwritten and returned as the second return value.

+func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {

+ prev = self.getStateObject(addr)

+ newobj = newObject(self, addr, Account{})

+ newobj.setNonce(0) // sets the object to dirty

+ if prev == nil {

+ self.journal.append(createObjectChange{account: &addr})

+ } else {

+ self.journal.append(resetObjectChange{prev: prev})

+ }

+ self.setStateObject(newobj)

+ return newobj, prev

+}

+

+// CreateAccount explicitly creates a state object. If a state object with the address

+// already exists the balance is carried over to the new account.

+//

+// CreateAccount is called during the EVM CREATE operation. The situation might arise that

+// a contract does the following:

+//

+// 1. sends funds to sha(account ++ (nonce + 1))

+// 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)

+//

+// Carrying over the balance ensures that Ether doesn't disappear.

+func (self *StateDB) CreateAccount(addr common.Address) {

+ newObj, prev := self.createObject(addr)

+ if prev != nil {

+ newObj.setBalance(prev.data.Balance)

+ }

+}

+

+func (db *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) error {

+ so := db.getStateObject(addr)

+ if so == nil {

+ return nil

+ }

+ it := trie.NewIterator(so.getTrie(db.db).NodeIterator(nil))

+

+ for it.Next() {

+ key := common.BytesToHash(db.trie.GetKey(it.Key))

+ if value, dirty := so.dirtyStorage[key]; dirty {

+ if !cb(key, value) {

+ return nil

+ }

+ continue

+ }

+

+ if len(it.Value) > 0 {

+ _, content, _, err := rlp.Split(it.Value)

+ if err != nil {

+ return err

+ }

+ if !cb(key, common.BytesToHash(content)) {

+ return nil

+ }

+ }

+ }

+ return nil

+}

+

+// Copy creates a deep, independent copy of the state.

+// Snapshots of the copied state cannot be applied to the copy.

+func (self *StateDB) Copy() *StateDB {

+ // Copy all the basic fields, initialize the memory ones

+ state := &StateDB{

+ db: self.db,

+ trie: self.db.CopyTrie(self.trie),

+ stateObjects: make(map[common.Address]*stateObject, len(self.journal.dirties)),

+ stateObjectsDirty: make(map[common.Address]struct{}, len(self.journal.dirties)),

+ refund: self.refund,

+ logs: make(map[common.Hash][]*types.Log, len(self.logs)),

+ logSize: self.logSize,

+ preimages: make(map[common.Hash][]byte, len(self.preimages)),

+ journal: newJournal(),

+ }

+ // Copy the dirty states, logs, and preimages

+ for addr := range self.journal.dirties {

+ // As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),

+ // and in the Finalise-method, there is a case where an object is in the journal but not

+ // in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for

+ // nil

+ if object, exist := self.stateObjects[addr]; exist {

+ state.stateObjects[addr] = object.deepCopy(state)

+ state.stateObjectsDirty[addr] = struct{}{}

+ }

+ }

+ // Above, we don't copy the actual journal. This means that if the copy is copied, the

+ // loop above will be a no-op, since the copy's journal is empty.

+ // Thus, here we iterate over stateObjects, to enable copies of copies

+ for addr := range self.stateObjectsDirty {

+ if _, exist := state.stateObjects[addr]; !exist {

+ state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state)

+ state.stateObjectsDirty[addr] = struct{}{}

+ }

+ }

+ for hash, logs := range self.logs {

+ cpy := make([]*types.Log, len(logs))

+ for i, l := range logs {

+ cpy[i] = new(types.Log)

+ *cpy[i] = *l

+ }

+ state.logs[hash] = cpy

+ }

+ for hash, preimage := range self.preimages {

+ state.preimages[hash] = preimage

+ }

+ return state

+}

+

+// Snapshot returns an identifier for the current revision of the state.

+func (self *StateDB) Snapshot() int {

+ id := self.nextRevisionId

+ self.nextRevisionId++

+ self.validRevisions = append(self.validRevisions, revision{id, self.journal.length()})

+ return id

+}

+

+// RevertToSnapshot reverts all state changes made since the given revision.

+func (self *StateDB) RevertToSnapshot(revid int) {

+ // Find the snapshot in the stack of valid snapshots.

+ idx := sort.Search(len(self.validRevisions), func(i int) bool {

+ return self.validRevisions[i].id >= revid

+ })

+ if idx == len(self.validRevisions) || self.validRevisions[idx].id != revid {

+ panic(fmt.Errorf("revision id %v cannot be reverted", revid))

+ }

+ snapshot := self.validRevisions[idx].journalIndex

+

+ // Replay the journal to undo changes and remove invalidated snapshots

+ self.journal.revert(self, snapshot)

+ self.validRevisions = self.validRevisions[:idx]

+}

+

+// GetRefund returns the current value of the refund counter.

+func (self *StateDB) GetRefund() uint64 {

+ return self.refund

+}

+

+// Finalise finalises the state by removing the self destructed objects

+// and clears the journal as well as the refunds.

+func (s *StateDB) Finalise(deleteEmptyObjects bool) {

+ for addr := range s.journal.dirties {

+ stateObject, exist := s.stateObjects[addr]

+ if !exist {

+ // ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2

+ // That tx goes out of gas, and although the notion of 'touched' does not exist there, the

+ // touch-event will still be recorded in the journal. Since ripeMD is a special snowflake,

+ // it will persist in the journal even though the journal is reverted. In this special circumstance,

+ // it may exist in `s.journal.dirties` but not in `s.stateObjects`.

+ // Thus, we can safely ignore it here

+ continue

+ }

+

+ if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {

+ s.deleteStateObject(stateObject)

+ } else {

+ stateObject.updateRoot(s.db)

+ s.updateStateObject(stateObject)

+ }

+ s.stateObjectsDirty[addr] = struct{}{}

+ }

+ // Invalidate journal because reverting across transactions is not allowed.

+ s.clearJournalAndRefund()

+}

+

+// IntermediateRoot computes the current root hash of the state trie.

+// It is called in between transactions to get the root hash that

+// goes into transaction receipts.

+func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {

+ s.Finalise(deleteEmptyObjects)

+

+ // Track the amount of time wasted on hashing the account trie

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now())

+ }

+ return s.trie.Hash()

+}

+

+// Prepare sets the current transaction hash and index and block hash which is

+// used when the EVM emits new state logs.

+func (self *StateDB) Prepare(thash, bhash common.Hash, ti int) {

+ self.thash = thash

+ self.bhash = bhash

+ self.txIndex = ti

+}

+

+func (s *StateDB) clearJournalAndRefund() {

+ s.journal = newJournal()

+ s.validRevisions = s.validRevisions[:0]

+ s.refund = 0

+}

+

+// Commit writes the state to the underlying in-memory trie database.

+func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) {

+ defer s.clearJournalAndRefund()

+

+ for addr := range s.journal.dirties {

+ s.stateObjectsDirty[addr] = struct{}{}

+ }

+ // Commit objects to the trie, measuring the elapsed time

+ for addr, stateObject := range s.stateObjects {

+ _, isDirty := s.stateObjectsDirty[addr]

+ switch {

+ case stateObject.suicided || (isDirty && deleteEmptyObjects && stateObject.empty()):

+ // If the object has been removed, don't bother syncing it

+ // and just mark it for deletion in the trie.

+ s.deleteStateObject(stateObject)

+ case isDirty:

+ // Write any contract code associated with the state object

+ if stateObject.code != nil && stateObject.dirtyCode {

+ s.db.TrieDB().InsertBlob(common.BytesToHash(stateObject.CodeHash()), stateObject.code)

+ stateObject.dirtyCode = false

+ }

+ // Write any storage changes in the state object to its storage trie.

+ if err := stateObject.CommitTrie(s.db); err != nil {

+ return common.Hash{}, err

+ }

+ // Update the object in the main account trie.

+ s.updateStateObject(stateObject)

+ }

+ delete(s.stateObjectsDirty, addr)

+ }

+ // Write the account trie changes, measuing the amount of wasted time

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountCommits += time.Since(start) }(time.Now())

+ }

+ root, err = s.trie.Commit(func(leaf []byte, parent common.Hash) error {

+ var account Account

+ if err := rlp.DecodeBytes(leaf, &account); err != nil {

+ return nil

+ }

+ if account.Root != emptyRoot {

+ s.db.TrieDB().Reference(account.Root, parent)

+ }

+ code := common.BytesToHash(account.CodeHash)

+ if code != emptyCode {

+ s.db.TrieDB().Reference(code, parent)

+ }

+ return nil

+ })

+ return root, err

+}

+// Copyright 2015 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+package state

+

+import (

+ "bytes"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/ethdb"

+ "github.com/ava-labs/go-ethereum/rlp"

+ "github.com/ava-labs/go-ethereum/trie"

+)

+

+// NewStateSync create a new state trie download scheduler.

+func NewStateSync(root common.Hash, database ethdb.KeyValueReader, bloom *trie.SyncBloom) *trie.Sync {

+ var syncer *trie.Sync

+ callback := func(leaf []byte, parent common.Hash) error {

+ var obj Account

+ if err := rlp.Decode(bytes.NewReader(leaf), &obj); err != nil {

+ return err

+ }

+ syncer.AddSubTrie(obj.Root, 64, parent, nil)

+ syncer.AddRawEntry(common.BytesToHash(obj.CodeHash), 64, parent)

+ return nil

+ }

+ syncer = trie.NewSync(root, database, callback, bloom)

+ return syncer

+}

+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/vm"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/consensus"

+ "github.com/ava-labs/coreth/consensus/misc"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/vm"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/core/vm"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/params"

+ "github.com/ava-labs/coreth/core/state"

+ "github.com/ava-labs/coreth/core/types"

+ "github.com/ava-labs/coreth/core/vm"

+// Copyright 2014 The go-ethereum Authors

+// This file is part of the go-ethereum library.

+//

+// The go-ethereum 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 go-ethereum 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 go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

+

+// Package types contains data types related to Ethereum consensus.

+package types

+

+import (

+ "encoding/binary"

+ "fmt"

+ "io"

+ "math/big"

+ "reflect"

+ "sort"

+ "sync/atomic"

+ "time"

+

+ "github.com/ava-labs/go-ethereum/common"

+ "github.com/ava-labs/go-ethereum/common/hexutil"

+ "github.com/ava-labs/go-ethereum/rlp"

+ "golang.org/x/crypto/sha3"

+)

+

+var (

+ EmptyRootHash = DeriveSha(Transactions{})

+ EmptyUncleHash = rlpHash([]*Header(nil))

+)

+

+// A BlockNonce is a 64-bit hash which proves (combined with the

+// mix-hash) that a sufficient amount of computation has been carried

+// out on a block.

+type BlockNonce [8]byte

+

+// EncodeNonce converts the given integer to a block nonce.

+func EncodeNonce(i uint64) BlockNonce {

+ var n BlockNonce

+ binary.BigEndian.PutUint64(n[:], i)

+ return n

+}

+

+// Uint64 returns the integer value of a block nonce.

+func (n BlockNonce) Uint64() uint64 {

+ return binary.BigEndian.Uint64(n[:])

+}

+

+// MarshalText encodes n as a hex string with 0x prefix.

+func (n BlockNonce) MarshalText() ([]byte, error) {

+ return hexutil.Bytes(n[:]).MarshalText()

+}

+

+// UnmarshalText implements encoding.TextUnmarshaler.

+func (n *BlockNonce) UnmarshalText(input []byte) error {

+ return hexutil.UnmarshalFixedText("BlockNonce", input, n[:])

+}

+

+//go:generate gencodec -type Header -field-override headerMarshaling -out gen_header_json.go

+

+// Header represents a block header in the Ethereum blockchain.

+type Header struct {

+ ParentHash common.Hash `json:"parentHash" gencodec:"required"`

+ UncleHash common.Hash `json:"sha3Uncles" gencodec:"required"`

+ Coinbase common.Address `json:"miner" gencodec:"required"`

+ Root common.Hash `json:"stateRoot" gencodec:"required"`

+ TxHash common.Hash `json:"transactionsRoot" gencodec:"required"`

+ ReceiptHash common.Hash `json:"receiptsRoot" gencodec:"required"`

+ Bloom Bloom `json:"logsBloom" gencodec:"required"`

+ Difficulty *big.Int `json:"difficulty" gencodec:"required"`

+ Number *big.Int `json:"number" gencodec:"required"`

+ GasLimit uint64 `json:"gasLimit" gencodec:"required"`

+ GasUsed uint64 `json:"gasUsed" gencodec:"required"`

+ Time uint64 `json:"timestamp" gencodec:"required"`

+ Extra []byte `json:"extraData" gencodec:"required"`

+ MixDigest common.Hash `json:"mixHash"`

+ Nonce BlockNonce `json:"nonce"`

+}

+

+// field type overrides for gencodec

+type headerMarshaling struct {

+ Difficulty *hexutil.Big

+ Number *hexutil.Big

+ GasLimit hexutil.Uint64

+ GasUsed hexutil.Uint64

+ Time hexutil.Uint64

+ Extra hexutil.Bytes

+ Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON

+}

+

+// Hash returns the block hash of the header, which is simply the keccak256 hash of its

+// RLP encoding.

+func (h *Header) Hash() common.Hash {

+ return rlpHash(h)

+}

+

+var headerSize = common.StorageSize(reflect.TypeOf(Header{}).Size())

+

+// Size returns the approximate memory used by all internal contents. It is used

+// to approximate and limit the memory consumption of various caches.

+func (h *Header) Size() common.StorageSize {

+ return headerSize + common.StorageSize(len(h.Extra)+(h.Difficulty.BitLen()+h.Number.BitLen())/8)

+}

+

+// SanityCheck checks a few basic things -- these checks are way beyond what

+// any 'sane' production values should hold, and can mainly be used to prevent

+// that the unbounded fields are stuffed with junk data to add processing

+// overhead

+func (h *Header) SanityCheck() error {

+ if h.Number != nil && !h.Number.IsUint64() {

+ return fmt.Errorf("too large block number: bitlen %d", h.Number.BitLen())

+ }

+ if h.Difficulty != nil {

+ if diffLen := h.Difficulty.BitLen(); diffLen > 80 {

+ return fmt.Errorf("too large block difficulty: bitlen %d", diffLen)

+ }

+ }

+ if eLen := len(h.Extra); eLen > 100*1024 {

+ return fmt.Errorf("too large block extradata: size %d", eLen)

+ }

+ return nil

+}

+

+func rlpHash(x interface{}) (h common.Hash) {

+ hw := sha3.NewLegacyKeccak256()

+ rlp.Encode(hw, x)

+ hw.Sum(h[:0])

+ return h

+}

+

+// Body is a simple (mutable, non-safe) data container for storing and moving

+// a block's data contents (transactions and uncles) together.

+type Body struct {

+ Transactions []*Transaction

+ Uncles []*Header

+}

+

+// Block represents an entire block in the Ethereum blockchain.

+type Block struct {

+ header *Header

+ uncles []*Header

+ transactions Transactions

+

+ // caches

+ hash atomic.Value

+ size atomic.Value

+

+ // Td is used by package core to store the total difficulty

+ // of the chain up to and including the block.

+ td *big.Int

+

+ // These fields are used by package eth to track

+ // inter-peer block relay.

+ ReceivedAt time.Time

+ ReceivedFrom interface{}

+}

+

+// DeprecatedTd is an old relic for extracting the TD of a block. It is in the

+// code solely to facilitate upgrading the database from the old format to the

+// new, after which it should be deleted. Do not use!

+func (b *Block) DeprecatedTd() *big.Int {

+ return b.td

+}

+

+// [deprecated by eth/63]

+// StorageBlock defines the RLP encoding of a Block stored in the

+// state database. The StorageBlock encoding contains fields that

+// would otherwise need to be recomputed.

+type StorageBlock Block

+

+// "external" block encoding. used for eth protocol, etc.

+type extblock struct {

+ Header *Header

+ Txs []*Transaction

+ Uncles []*Header

+}

+

+// [deprecated by eth/63]

+// "storage" block encoding. used for database.

+type storageblock struct {

+ Header *Header

+ Txs []*Transaction

+ Uncles []*Header

+ TD *big.Int

+}

+

+// NewBlock creates a new block. The input data is copied,

+// changes to header and to the field values will not affect the

+// block.

+//

+// The values of TxHash, UncleHash, ReceiptHash and Bloom in header

+// are ignored and set to values derived from the given txs, uncles

+// and receipts.

+func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt) *Block {

+ b := &Block{header: CopyHeader(header), td: new(big.Int)}

+

+ // TODO: panic if len(txs) != len(receipts)

+ if len(txs) == 0 {

+ b.header.TxHash = EmptyRootHash

+ } else {

+ b.header.TxHash = DeriveSha(Transactions(txs))

+ b.transactions = make(Transactions, len(txs))

+ copy(b.transactions, txs)

+ }

+

+ if len(receipts) == 0 {

+ b.header.ReceiptHash = EmptyRootHash

+ } else {

+ b.header.ReceiptHash = DeriveSha(Receipts(receipts))

+ b.header.Bloom = CreateBloom(receipts)

+ }

+

+ if len(uncles) == 0 {

+ b.header.UncleHash = EmptyUncleHash

+ } else {

+ b.header.UncleHash = CalcUncleHash(uncles)

+ b.uncles = make([]*Header, len(uncles))

+ for i := range uncles {

+ b.uncles[i] = CopyHeader(uncles[i])

+ }

+ }

+

+ return b

+}

+

+// NewBlockWithHeader creates a block with the given header data. The

+// header data is copied, changes to header and to the field values

+// will not affect the block.

+func NewBlockWithHeader(header *Header) *Block {

+ return &Block{header: CopyHeader(header)}

+}

+

+// CopyHeader creates a deep copy of a block header to prevent side effects from

+// modifying a header variable.

+func CopyHeader(h *Header) *Header {

+ cpy := *h

+ if cpy.Difficulty = new(big.Int); h.Difficulty != nil {

+ cpy.Difficulty.Set(h.Difficulty)

+ }

+ if cpy.Number = new(big.Int); h.Number != nil {

+ cpy.Number.Set(h.Number)

+ }

+ if len(h.Extra) > 0 {

+ cpy.Extra = make([]byte, len(h.Extra))

+ copy(cpy.Extra, h.Extra)

+ }

+ return &cpy

+}

+

+// DecodeRLP decodes the Ethereum

+func (b *Block) DecodeRLP(s *rlp.Stream) error {

+ var eb extblock

+ _, size, _ := s.Kind()

+ if err := s.Decode(&eb); err != nil {

+ return err

+ }

+ b.header, b.uncles, b.transactions = eb.Header, eb.Uncles, eb.Txs

+ b.size.Store(common.StorageSize(rlp.ListSize(size)))

+ return nil

+}

+

+// EncodeRLP serializes b into the Ethereum RLP block format.

+func (b *Block) EncodeRLP(w io.Writer) error {

+ return rlp.Encode(w, extblock{

+ Header: b.header,

+ Txs: b.transactions,

+ Uncles: b.uncles,

+ })

+}

+

+// [deprecated by eth/63]

+func (b *StorageBlock) DecodeRLP(s *rlp.Stream) error {

+ var sb storageblock

+ if err := s.Decode(&sb); err != nil {

+ return err

+ }

+ b.header, b.uncles, b.transactions, b.td = sb.Header, sb.Uncles, sb.Txs, sb.TD

+ return nil

+}

+

+// TODO: copies

+

+func (b *Block) Uncles() []*Header { return b.uncles }

+func (b *Block) Transactions() Transactions { return b.transactions }

+

+func (b *Block) Transaction(hash common.Hash) *Transaction {

+ for _, transaction := range b.transactions {

+ if transaction.Hash() == hash {

+ return transaction

+ }

+ }

+ return nil

+}

+

+func (b *Block) Number() *big.Int { return new(big.Int).Set(b.header.Number) }

+func (b *Block) GasLimit() uint64 { return b.header.GasLimit }

+func (b *Block) GasUsed() uint64 { return b.header.GasUsed }

+func (b *Block) Difficulty() *big.Int { return new(big.Int).Set(b.header.Difficulty) }

+func (b *Block) Time() uint64 { return b.header.Time }

+

+func (b *Block) NumberU64() uint64 { return b.header.Number.Uint64() }

+func (b *Block) MixDigest() common.Hash { return b.header.MixDigest }

+func (b *Block) Nonce() uint64 { return binary.BigEndian.Uint64(b.header.Nonce[:]) }

+func (b *Block) Bloom() Bloom { return b.header.Bloom }

+func (b *Block) Coinbase() common.Address { return b.header.Coinbase }

+func (b *Block) Root() common.Hash { return b.header.Root }

+func (b *Block) ParentHash() common.Hash { return b.header.ParentHash }

+func (b *Block) TxHash() common.Hash { return b.header.TxHash }

+func (b *Block) ReceiptHash() common.Hash { return b.header.ReceiptHash }

+func (b *Block) UncleHash() common.Hash { return b.header.UncleHash }

+func (b *Block) Extra() []byte { return common.CopyBytes(b.header.Extra) }

+

+func (b *Block) Header() *Header { return CopyHeader(b.header) }

+

+// Body returns the non-header content of the block.

+func (b *Block) Body() *Body { return &Body{b.transactions, b.uncles} }

+

+// Size returns the true RLP encoded storage size of the block, either by encoding

+// and returning it, or returning a previsouly cached value.

+func (b *Block) Size() common.StorageSize {

+ if size := b.size.Load(); size != nil {

+ return size.(common.StorageSize)

+ }

+ c := writeCounter(0)

+ rlp.Encode(&c, b)

+ b.size.Store(common.StorageSize(c))

+ return common.StorageSize(c)

+}

+

+// SanityCheck can be used to prevent that unbounded fields are

+// stuffed with junk data to add processing overhead

+func (b *Block) SanityCheck() error {

+ return b.header.SanityCheck()

+}

+

+type writeCounter common.StorageSize