database

type BlockAnnouncement struct {
	Hash   common.Hash
	Number uint64
}

type ClickHouse struct {
	// contains filtered or unexported fields
}

type ClickHouseOptions struct {
	DSN                              string
	SensorID                         string
	ChainID                          uint64
	MaxConcurrency                   int
	ShouldWriteBlocks                bool
	ShouldWriteBlockEvents           bool
	ShouldWriteFirstBlockEvent       bool
	ShouldWriteTransactions          bool
	ShouldWriteTransactionEvents     bool
	ShouldWriteFirstTransactionEvent bool
	ShouldWritePeers                 bool
}

type Database interface {
	// WriteBlock records a block delivered whole (NewBlock). The block row is
	// written if ShouldWriteBlocks returns true; the event is written if either
	// ShouldWriteBlockEvents or ShouldWriteFirstBlockEvent returns true, because
	// a whole-block delivery is one event per block per sensor and is the only
	// place a block first seen this way is observed.
	WriteBlock(context.Context, *enode.Node, *types.Block, *big.Int, time.Time)

	// WriteBlockHeaders will write the block headers if ShouldWriteBlocks
	// returns true.
	WriteBlockHeaders(context.Context, []*types.Header, time.Time, bool)

	// WriteBlockEvents appends an inbound block event (peer, hash, height, time)
	// for each announcement — one per peer we received the announcement from. The
	// caller decides which announcements to pass (every one for the full per-peer
	// stream, or just the first-seen ones); the backend only appends.
	WriteBlockEvents(context.Context, *enode.Node, []BlockAnnouncement, time.Time)

	// WriteBlockHashFirstSeen records the earliest event for a block hash on
	// the block entity itself (Datastore's TimeFirstSeenHash). Backends that
	// derive first-seen from the event stream (e.g. ClickHouse) treat it as a
	// no-op.
	WriteBlockHashFirstSeen(context.Context, *enode.Node, common.Hash, time.Time)

	// WriteBlockBody writes the transactions carried in the block body (the block
	// row itself comes from WriteBlock/WriteBlockHeaders). The announcement carries
	// the height, which the eth block body does not, so backends that key
	// observations by block number can record the body's arrival. Backends with a
	// separate transactions table (e.g. ClickHouse) gate this on
	// ShouldWriteTransactions; the Datastore backend gates on ShouldWriteBlocks
	// because it links the transactions and uncles onto the block entity.
	WriteBlockBody(context.Context, *eth.BlockBody, BlockAnnouncement, time.Time)

	// WriteTransactions writes the transaction bodies if ShouldWriteTransactions
	// returns true. Transaction events are recorded separately via
	// WriteTransactionEvents at announcement time.
	WriteTransactions(context.Context, *enode.Node, []*types.Transaction, time.Time)

	// WriteTransactionEvents appends an inbound transaction event (peer, hash,
	// time) for each hash — the tx mirror of WriteBlockEvents. The caller
	// decides which hashes to pass (every announcement for the full per-peer
	// stream, or just the first-seen ones); the backend only appends.
	WriteTransactionEvents(context.Context, *enode.Node, []common.Hash, time.Time)

	// WritePeers will write the connected peers to the database.
	WritePeers(context.Context, []*p2p.Peer, time.Time)

	// HasBlock will return whether the block is in the database. If the database
	// client has not been initialized this will always return true.
	HasBlock(context.Context, common.Hash) bool

	MaxConcurrentWrites() int
	ShouldWriteBlocks() bool
	ShouldWriteBlockEvents() bool
	ShouldWriteFirstBlockEvent() bool
	ShouldWriteTransactions() bool
	ShouldWriteTransactionEvents() bool
	ShouldWriteFirstTransactionEvent() bool
	ShouldWritePeers() bool

	// NodeList will return a list of enode URLs.
	NodeList(ctx context.Context, limit int) ([]string, error)

	// Close flushes any buffered writes and releases the underlying database
	// connection. It blocks until in-flight writes have drained (or their
	// shutdown flush times out). Implementations with no resources to release
	// return nil.
	Close() error
}

type Datastore struct {
	// contains filtered or unexported fields
}

type DatastoreBlock struct {
	*DatastoreHeader
	TotalDifficulty     string           `datastore:",noindex"`
	Transactions        []*datastore.Key `datastore:",noindex"`
	Uncles              []*datastore.Key `datastore:",noindex"`
	TimeFirstSeenHash   time.Time
	SensorFirstSeenHash string
}

type DatastoreEvent struct {
	SensorId string
	PeerId   string
	Hash     *datastore.Key
	Time     time.Time
	TTL      time.Time
}

type DatastoreHeader struct {
	ParentHash      *datastore.Key
	UncleHash       string `datastore:",noindex"`
	Coinbase        string `datastore:",noindex"`
	Root            string `datastore:",noindex"`
	TxHash          string `datastore:",noindex"`
	ReceiptHash     string `datastore:",noindex"`
	Bloom           []byte `datastore:",noindex"`
	Difficulty      string `datastore:",noindex"`
	Number          string
	GasLimit        string `datastore:",noindex"`
	GasUsed         string
	Time            time.Time
	Extra           []byte `datastore:",noindex"`
	MixDigest       string `datastore:",noindex"`
	Nonce           string `datastore:",noindex"`
	BaseFee         string `datastore:",noindex"`
	TimeFirstSeen   time.Time
	TTL             time.Time
	IsParent        bool
	SensorFirstSeen string
}

type DatastoreOptions struct {
	ProjectID                        string
	DatabaseID                       string
	SensorID                         string
	ChainID                          uint64
	MaxConcurrency                   int
	ShouldWriteBlocks                bool
	ShouldWriteBlockEvents           bool
	ShouldWriteFirstBlockEvent       bool
	ShouldWriteTransactions          bool
	ShouldWriteTransactionEvents     bool
	ShouldWriteFirstTransactionEvent bool
	ShouldWritePeers                 bool
	TTL                              time.Duration
}

type DatastorePeer struct {
	Name         string
	Caps         []string `datastore:",noindex"`
	URL          string
	LastSeenBy   string
	TimeLastSeen time.Time
	TTL          time.Time
}

type DatastoreTransaction struct {
	Data            []byte `datastore:",noindex"`
	From            string
	Gas             string `datastore:",noindex"`
	GasFeeCap       string `datastore:",noindex"`
	GasPrice        string `datastore:",noindex"`
	GasTipCap       string `datastore:",noindex"`
	Nonce           string `datastore:",noindex"`
	To              string
	Value           string `datastore:",noindex"`
	V, R, S         string `datastore:",noindex"`
	Time            time.Time
	TimeFirstSeen   time.Time
	TTL             time.Time
	Type            int16
	SensorFirstSeen string
}

type JSONBlock struct {
	Type            string    `json:"type"`
	SensorID        string    `json:"sensor_id"`
	Hash            string    `json:"hash"`
	ParentHash      string    `json:"parent_hash"`
	Number          uint64    `json:"number"`
	Timestamp       uint64    `json:"timestamp"`
	GasLimit        uint64    `json:"gas_limit"`
	GasUsed         uint64    `json:"gas_used"`
	Difficulty      string    `json:"difficulty,omitempty"`
	TotalDifficulty string    `json:"total_difficulty,omitempty"`
	BaseFee         string    `json:"base_fee,omitempty"`
	TxCount         int       `json:"tx_count"`
	UncleCount      int       `json:"uncle_count"`
	TimeFirstSeen   time.Time `json:"time_first_seen"`
	IsParent        bool      `json:"is_parent"`
}

type JSONBlockEvent struct {
	Type      string    `json:"type"`
	SensorID  string    `json:"sensor_id"`
	PeerID    string    `json:"peer_id"`
	Hash      string    `json:"hash"`
	Number    uint64    `json:"number,omitempty"`
	Timestamp time.Time `json:"timestamp"`
}

type JSONBlockHashFirstSeen struct {
	Type          string    `json:"type"`
	SensorID      string    `json:"sensor_id"`
	Hash          string    `json:"hash"`
	TimeFirstSeen time.Time `json:"time_first_seen"`
}

type JSONDatabase struct {
	// contains filtered or unexported fields
}

type JSONDatabaseOptions struct {
	SensorID                     string
	ChainID                      uint64
	MaxConcurrency               int
	ShouldWriteBlocks            bool
	ShouldWriteBlockEvents       bool
	ShouldWriteTransactions      bool
	ShouldWriteTransactionEvents bool
	ShouldWritePeers             bool
}

type JSONPeer struct {
	Type         string    `json:"type"`
	SensorID     string    `json:"sensor_id"`
	ID           string    `json:"id"`
	Name         string    `json:"name"`
	URL          string    `json:"url"`
	Caps         []string  `json:"caps"`
	TimeLastSeen time.Time `json:"time_last_seen"`
}

type JSONTransaction struct {
	Type          string    `json:"type"`
	SensorID      string    `json:"sensor_id"`
	Hash          string    `json:"hash"`
	From          string    `json:"from,omitempty"`
	To            string    `json:"to,omitempty"`
	Value         string    `json:"value"`
	Gas           uint64    `json:"gas"`
	GasPrice      string    `json:"gas_price"`
	GasFeeCap     string    `json:"gas_fee_cap,omitempty"`
	GasTipCap     string    `json:"gas_tip_cap,omitempty"`
	Nonce         uint64    `json:"nonce"`
	TxType        uint8     `json:"tx_type"`
	TimeFirstSeen time.Time `json:"time_first_seen"`
}

type JSONTransactionEvent struct {
	Type      string    `json:"type"`
	SensorID  string    `json:"sensor_id"`
	PeerID    string    `json:"peer_id"`
	Hash      string    `json:"hash"`
	Timestamp time.Time `json:"timestamp"`
}