Fantom-foundation/go-lachesis

package topicsdb

import (
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/ethdb"
    "github.com/ethereum/go-ethereum/log"
)

type (
    logrecBuilder struct {
        types.Log

        ID          ID
        conditions  uint8
        topicsCount uint8

        ok    chan struct{}
        ready chan error
    }
)

func newLogrecBuilder(logrec ID, conditions uint8, topicCount uint8) *logrecBuilder {
    rec := &logrecBuilder{
        Log: types.Log{
            BlockNumber: logrec.BlockNumber(),
            TxHash:      logrec.TxHash(),
            Index:       logrec.Index(),
            Topics:      make([]common.Hash, topicCount),
        },
        ID:          logrec,
        conditions:  conditions,
        topicsCount: topicCount,
    }

    return rec
}

func (rec *logrecBuilder) Build() (r *types.Log, err error) {
    if rec.ready != nil {
        var complete bool
        err, complete = <-rec.ready
        if !complete {
            return
        }
    }

    r = &rec.Log
    return
}

// MatchedWith count of conditions.
func (rec *logrecBuilder) MatchedWith(count uint8) {
    if rec.conditions > count {
        rec.conditions -= count
        return
    }
    rec.conditions = 0
    if rec.ok != nil {
        rec.ok <- struct{}{}
    }
}

// IsMatched if it is matched with the all conditions.
func (rec *logrecBuilder) IsMatched() bool {
    return rec.conditions == 0
}

// SetOtherTopic appends topic.
func (rec *logrecBuilder) SetOtherTopic(pos uint8, topic common.Hash) {
    if pos >= rec.topicsCount {
        log.Crit("inconsistent table.Others", "param", "topicN")
    }

    var empty common.Hash
    if rec.Topics[pos] != empty {
        return
    }

    rec.Topics[pos] = topic
}

// Fetch log record's data.
func (rec *logrecBuilder) Fetch(
    othersTable ethdb.Iteratee,
    logrecTable ethdb.KeyValueReader,
) (err error) {
    // others
    it := othersTable.NewIterator(rec.ID.Bytes(), nil)
    for it.Next() {
        pos := extractTopicPos(it.Key())
        topic := common.BytesToHash(it.Value())
        rec.SetOtherTopic(pos, topic)
    }

    err = it.Error()
    if err != nil {
        return
    }

    it.Release()

    // fields
    buf, err := logrecTable.Get(rec.ID.Bytes())
    if err != nil {
        return
    }
    offset := 0
    rec.Address = common.BytesToAddress(buf[offset : offset+common.AddressLength])
    offset += common.AddressLength
    rec.BlockHash = common.BytesToHash(buf[offset : offset+common.HashLength])
    offset += common.HashLength
    rec.Data = buf[offset:]

    return
}