From e8b93d7597e69e809b735e72ba8cec53f7e7fbe5 Mon Sep 17 00:00:00 2001 From: Austin Roberts Date: Tue, 31 Aug 2021 15:24:20 -0500 Subject: [PATCH] Initial commit --- core/interface.go | 133 ++++++++++++++++++++++++++++++++++++++++ core/types.go | 36 +++++++++++ go.mod | 5 ++ go.sum | 2 + restricted/database.go | 127 ++++++++++++++++++++++++++++++++++++++ restricted/interface.go | 11 ++++ 6 files changed, 314 insertions(+) create mode 100644 core/interface.go create mode 100644 core/types.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 restricted/database.go create mode 100644 restricted/interface.go diff --git a/core/interface.go b/core/interface.go new file mode 100644 index 0000000..97861b4 --- /dev/null +++ b/core/interface.go @@ -0,0 +1,133 @@ +package core + +import ( + "context" + "math/big" + "time" + "github.com/holiman/uint256" +) + +type Backend interface { + // General Ethereum API + Downloader() Downloader + SuggestGasTipCap(ctx context.Context) (*big.Int, error) + // ChainDb() Database + // AccountManager() *accounts.Manager + ExtRPCEnabled() bool + RPCGasCap() uint64 // global gas cap for eth_call over rpc: DoS protection + RPCTxFeeCap() float64 // global tx fee cap for all transaction related APIs + UnprotectedAllowed() bool // allows only for EIP155 transactions. + + // Blockchain API + SetHead(number uint64) + HeaderByNumber(ctx context.Context, number int64) ([]byte, error) // RLP encoded header + HeaderByHash(ctx context.Context, hash Hash) ([]byte, error) + // HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) + CurrentHeader() []byte // RLP encoded header + CurrentBlock() []byte // RLP encoded block + BlockByNumber(ctx context.Context, number int64) ([]byte, error) // RLP encoded block + BlockByHash(ctx context.Context, hash Hash) ([]byte, error) // RLP encoded block + // BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) + // StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) + // StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) + GetReceipts(ctx context.Context, hash Hash) ([]byte, error) // JSON encoded receipt (YES, JSON) + GetTd(ctx context.Context, hash Hash) *big.Int + + SubscribeChainEvent(ch chan<- ChainEvent) Subscription + SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) Subscription + SubscribeChainSideEvent(ch chan<- ChainSideEvent) Subscription + + // Transaction pool API + SendTx(ctx context.Context, signedTx []byte) error // RLP Encoded Transaction + GetTransaction(ctx context.Context, txHash Hash) ([]byte, Hash, uint64, uint64, error) // RLP Encoded transaction + GetPoolTransactions() ([][]byte, error) // []RLP ecnoded transactions + GetPoolTransaction(txHash Hash) []byte // RLP encoded transaction + GetPoolNonce(ctx context.Context, addr Address) (uint64, error) + Stats() (pending int, queued int) + TxPoolContent() (map[Address][][]byte, map[Address][][]byte) // RLP encoded transactions + SubscribeNewTxsEvent(chan<- NewTxsEvent) Subscription + + // Filter API + BloomStatus() (uint64, uint64) + GetLogs(ctx context.Context, blockHash Hash) ([][]byte, error) // []RLP encoded logs + SubscribeLogsEvent(ch chan<- [][]byte) Subscription // []RLP encoded logs + SubscribePendingLogsEvent(ch chan<- [][]byte) Subscription // RLP Encoded logs + SubscribeRemovedLogsEvent(ch chan<- []byte) Subscription // RLP encoded logs + + // ChainConfig() *params.ChainConfig + // Engine() consensus.Engine +} + + +type OpCode byte + +type TracerResult interface { + CaptureStart(from Address, to Address, create bool, input []byte, gas uint64, value *big.Int) + CaptureState(pc uint64, op OpCode, gas, cost uint64, scope ScopeContext, rData []byte, depth int, err error) + CaptureFault(pc uint64, op OpCode, gas, cost uint64, scope ScopeContext, depth int, err error) + CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) +} + +type ScopeContext interface { + Memory() Memory + Stack() Stack + Contract() Contract +} + +type Memory interface { + GetCopy() []byte + Len() int +} + +type Stack interface { + Back(n int) *uint256.Int + Len() int +} + +type Contract interface { + AsDelegate() Contract + GetOp(n uint64) OpCode + GetByte(n uint64) byte + Caller() Address + UseGas(gas uint64) (ok bool) + Address() Address + Value() *big.Int +} + +type Downloader interface{ + Progress() Progress +} + +type Progress interface{ + StartingBlock() uint64 + CurrentBlock() uint64 + HighestBlock() uint64 + PulledStates() uint64 + KnownStates() uint64 +} + + +type Node interface{ + Server() Server + DataDir() string + InstanceDir() string + IPCEndpoint() string + HTTPEndpoint() string + WSEndpoint() string + ResolvePath(x string) string +} + + +type Server interface{ + PeerCount() int +} + + +type Logger interface { + Trace(string, ...interface{}) + Debug(string, ...interface{}) + Info(string, ...interface{}) + Warn(string, ...interface{}) + Crit(string, ...interface{}) + Error(string, ...interface{}) +} diff --git a/core/types.go b/core/types.go new file mode 100644 index 0000000..59a7d26 --- /dev/null +++ b/core/types.go @@ -0,0 +1,36 @@ +package core + +type Hash [32]byte +type Address [20]byte + + + +type ChainEvent struct { + Block []byte // RLP Encoded block + Hash Hash + Logs []byte // RLP encoded logs +} + +type ChainSideEvent struct { + Block []byte // RLP Encoded block +} + +type ChainHeadEvent struct{ + Block []byte // RLP Encoded block +} + +type NewTxsEvent struct{ + Txs [][]byte // []RLP encoded transaction +} + +type Subscription interface { + Err() <-chan error // returns the error channel + Unsubscribe() // cancels sending of events, closing the error channel +} + +type API struct { + Namespace string + Version string + Service interface{} + Public bool +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..3d73e23 --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module github.com/openrelayxyz/plugeth-utils + +go 1.16 + +require github.com/holiman/uint256 v1.2.0 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..6252fa8 --- /dev/null +++ b/go.sum @@ -0,0 +1,2 @@ +github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM= +github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= diff --git a/restricted/database.go b/restricted/database.go new file mode 100644 index 0000000..2422116 --- /dev/null +++ b/restricted/database.go @@ -0,0 +1,127 @@ +// 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 . + +// Package ethdb defines the interfaces for an Ethereum data store. +package restricted + +import "io" + +// KeyValueReader wraps the Has and Get method of a backing data store. +type KeyValueReader interface { + // Has retrieves if a key is present in the key-value data store. + Has(key []byte) (bool, error) + + // Get retrieves the given key if it's present in the key-value data store. + Get(key []byte) ([]byte, error) +} + +// KeyValueWriter wraps the Put method of a backing data store. +type KeyValueWriter interface { + // Put inserts the given value into the key-value data store. + Put(key []byte, value []byte) error + + // Delete removes the key from the key-value data store. + Delete(key []byte) error +} + +// Stater wraps the Stat method of a backing data store. +type Stater interface { + // Stat returns a particular internal stat of the database. + Stat(property string) (string, error) +} + +// Compacter wraps the Compact method of a backing data store. +type Compacter interface { + // 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. + Compact(start []byte, limit []byte) error +} + +// KeyValueStore contains all the methods required to allow handling different +// key-value data stores backing the high level database. +type KeyValueStore interface { + KeyValueReader + KeyValueWriter + Stater + Compacter + io.Closer +} + +// AncientReader contains the methods required to read from immutable ancient data. +type AncientReader interface { + // HasAncient returns an indicator whether the specified data exists in the + // ancient store. + HasAncient(kind string, number uint64) (bool, error) + + // Ancient retrieves an ancient binary blob from the append-only immutable files. + Ancient(kind string, number uint64) ([]byte, error) + + // Ancients returns the ancient item numbers in the ancient store. + Ancients() (uint64, error) + + // AncientSize returns the ancient size of the specified category. + AncientSize(kind string) (uint64, error) +} + +// AncientWriter contains the methods required to write to immutable ancient data. +type AncientWriter interface { + // AppendAncient injects all binary blobs belong to block at the end of the + // append-only immutable table files. + AppendAncient(number uint64, hash, header, body, receipt, td []byte) error + + // TruncateAncients discards all but the first n ancient data from the ancient store. + TruncateAncients(n uint64) error + + // Sync flushes all in-memory ancient store data to disk. + Sync() error +} + +// Reader contains the methods required to read data from both key-value as well as +// immutable ancient data. +type Reader interface { + KeyValueReader + AncientReader +} + +// Writer contains the methods required to write data to both key-value as well as +// immutable ancient data. +type Writer interface { + KeyValueWriter + AncientWriter +} + +// AncientStore contains all the methods required to allow handling different +// ancient data stores backing immutable chain data store. +type AncientStore interface { + AncientReader + AncientWriter + io.Closer +} + +// Database contains all the methods required by the high level database to not +// only access the key-value data store but also the chain freezer. +type Database interface { + Reader + Writer + Stater + Compacter + io.Closer +} diff --git a/restricted/interface.go b/restricted/interface.go new file mode 100644 index 0000000..d776129 --- /dev/null +++ b/restricted/interface.go @@ -0,0 +1,11 @@ +package restricted + +import ( + "github.com/openrelayxyz/plugeth-utils/core" +) + +type Backend interface { + core.Backend + // General Ethereum API + ChainDb() Database +}