Merge pull request ethereum#5 from OffchainLabs/backend

arbitrum: initial create backend and API

arbitrum/apibackend.go

@@ -0,0 +1,256 @@
+package arbitrum
+
+import (
+ "context"
+ "errors"
+ "math/big"
+ "time"
+
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/consensus"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/bloombits"
+ "github.com/ethereum/go-ethereum/core/rawdb"
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/core/vm"
+ "github.com/ethereum/go-ethereum/eth/filters"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/internal/ethapi"
+ "github.com/ethereum/go-ethereum/params"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+type APIBackend struct {
+ b *Backend
+}
+
+func createRegisterAPIBackend(backend *Backend) {
+ backend.apiBackend = &APIBackend{
+ b: backend,
+ }
+ backend.stack.RegisterAPIs(backend.apiBackend.GetAPIs())
+}
+
+func (a *APIBackend) GetAPIs() []rpc.API {
+ apis := ethapi.GetAPIs(a)
+
+ apis = append(apis, rpc.API{
+ Namespace: "eth",
+ Version: "1.0",
+ Service: filters.NewPublicFilterAPI(a, false, 5*time.Minute),
+ Public: true,
+ })
+ return apis
+}
+
+// General Ethereum API
+func (a *APIBackend) SyncProgress() ethereum.SyncProgress {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) ChainDb() ethdb.Database {
+ return a.b.ethDatabase
+}
+
+func (a *APIBackend) AccountManager() *accounts.Manager {
+ return a.b.stack.AccountManager()
+}
+
+func (a *APIBackend) ExtRPCEnabled() bool {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) RPCGasCap() uint64 {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) RPCTxFeeCap() float64 {
+ return a.b.ethConfig.RPCTxFeeCap
+}
+
+func (a *APIBackend) UnprotectedAllowed() bool {
+ return true // TODO: is that true?
+}
+
+// Blockchain API
+func (a *APIBackend) SetHead(number uint64) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
+ if number == rpc.LatestBlockNumber {
+ return a.b.blockChain.CurrentBlock().Header(), nil
+ }
+ return a.b.blockChain.GetHeaderByNumber(uint64(number.Int64())), nil
+}
+
+func (a *APIBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+ return a.b.blockChain.GetHeaderByHash(hash), nil
+}
+
+func (a *APIBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
+ number, isnum := blockNrOrHash.Number()
+ if isnum {
+ return a.HeaderByNumber(ctx, number)
+ }
+ hash, ishash := blockNrOrHash.Hash()
+ if ishash {
+ return a.HeaderByHash(ctx, hash)
+ }
+ return nil, errors.New("invalid arguments; neither block nor hash specified")
+}
+
+func (a *APIBackend) CurrentHeader() *types.Header {
+ return a.b.blockChain.CurrentHeader()
+}
+
+func (a *APIBackend) CurrentBlock() *types.Block {
+ return a.b.blockChain.CurrentBlock()
+}
+
+func (a *APIBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error) {
+ return a.b.blockChain.GetBlockByNumber(uint64(number.Int64())), nil
+}
+
+func (a *APIBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
+ return a.b.blockChain.GetBlockByHash(hash), nil
+}
+
+func (a *APIBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {
+ number, isnum := blockNrOrHash.Number()
+ if isnum {
+ return a.BlockByNumber(ctx, number)
+ }
+ hash, ishash := blockNrOrHash.Hash()
+ if ishash {
+ return a.BlockByHash(ctx, hash)
+ }
+ return nil, errors.New("invalid arguments; neither block nor hash specified")
+}
+
+func (a *APIBackend) stateAndHeaderFromHeader(header *types.Header, err error) (*state.StateDB, *types.Header, error) {
+ if err != nil {
+ return nil, header, err
+ }
+ if header == nil {
+ return nil, nil, errors.New("header not found")
+ }
+ state, err := a.b.blockChain.StateAt(header.Root)
+ return state, header, err
+}
+
+func (a *APIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
+ return a.stateAndHeaderFromHeader(a.HeaderByNumber(ctx, number))
+}
+
+func (a *APIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
+ return a.stateAndHeaderFromHeader(a.HeaderByNumberOrHash(ctx, blockNrOrHash))
+}
+
+func (a *APIBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) {
+ return a.b.blockChain.GetReceiptsByHash(hash), nil
+}
+
+func (a *APIBackend) GetTd(ctx context.Context, hash common.Hash) *big.Int {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
+ return a.b.blockChain.SubscribeChainEvent(ch)
+}
+
+func (a *APIBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
+ return a.b.blockChain.SubscribeChainHeadEvent(ch)
+}
+
+func (a *APIBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
+ return a.b.blockChain.SubscribeChainSideEvent(ch)
+}
+
+// Transaction pool API
+func (a *APIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
+ return a.b.EnqueueL2Message(signedTx)
+}
+
+func (a *APIBackend) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, error) {
+ tx, blockHash, blockNumber, index := rawdb.ReadTransaction(a.b.ethDatabase, txHash)
+ return tx, blockHash, blockNumber, index, nil
+}
+
+func (a *APIBackend) GetPoolTransactions() (types.Transactions, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) Stats() (pending int, queued int) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) TxPoolContent() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) TxPoolContentFrom(addr common.Address) (types.Transactions, types.Transactions) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
+ return a.b.SubscribeNewTxsEvent(ch)
+}
+
+// Filter API
+func (a *APIBackend) BloomStatus() (uint64, uint64) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
+ panic("not implemented") // TODO: Implement
+}
+
+func (a *APIBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
+ return a.b.blockChain.SubscribeLogsEvent(ch)
+}
+
+func (a *APIBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
+ //Arbitrum doesn't really need pending logs. Logs are published as soon as we know them..
+ return a.SubscribeLogsEvent(ch)
+}
+
+func (a *APIBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
+ return a.b.blockChain.SubscribeRemovedLogsEvent(ch)
+}
+
+func (a *APIBackend) ChainConfig() *params.ChainConfig {
+ return a.b.blockChain.Config()
+}
+
+func (a *APIBackend) Engine() consensus.Engine {
+ return a.b.blockChain.Engine()
+}

arbitrum/arbos_interface.go

@@ -0,0 +1,12 @@
+package arbitrum
+
+import (
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/types"
+)
+
+type ArbosWrapper interface {
+ BuildBlock(force bool) (*types.Block, types.Receipts, *state.StateDB)
+
+ EnqueueSequencerTx(tx *types.Transaction) error
+}

arbitrum/backend.go

@@ -0,0 +1,104 @@
+package arbitrum
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/eth/ethconfig"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/node"
+)
+
+type Backend struct {
+ arbos ArbosWrapper
+ blockChain *core.BlockChain
+ stack *node.Node
+ chainId *big.Int
+ apiBackend *APIBackend
+ ethConfig *ethconfig.Config
+ ethDatabase ethdb.Database
+
+ txFeed event.Feed
+ scope event.SubscriptionScope
+
+ chanTxs chan *types.Transaction
+ chanClose chan struct{} //close coroutine
+ chanNewBlock chan struct{} //create new L2 block unless empty
+}
+
+func NewBackend(stack *node.Node, config *ethconfig.Config, ethDatabase ethdb.Database, blockChain *core.BlockChain, chainId *big.Int, arbos ArbosWrapper) (*Backend, error) {
+ backend := &Backend{
+ arbos: arbos,
+ blockChain: blockChain,
+ stack: stack,
+ chainId: chainId,
+ ethConfig: config,
+ ethDatabase: ethDatabase,
+ chanTxs: make(chan *types.Transaction, 100),
+ chanClose: make(chan struct{}, 1),
+ chanNewBlock: make(chan struct{}, 1),
+ }
+ stack.RegisterLifecycle(backend)
+ go backend.segmentQueueRoutine()
+
+ createRegisterAPIBackend(backend)
+ return backend, nil
+}
+
+func (b *Backend) APIBackend() *APIBackend {
+ return b.apiBackend
+}
+
+func (b *Backend) EnqueueL2Message(tx *types.Transaction) error {
+ b.chanTxs <- tx
+ return nil
+}
+
+func (b *Backend) CloseBlock() {
+ b.chanNewBlock <- struct{}{}
+}
+
+func (b *Backend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
+ return b.scope.Track(b.txFeed.Subscribe(ch))
+}
+
+func (b *Backend) enqueueBlock(block *types.Block, reciepts types.Receipts, state *state.StateDB) {
+ if block == nil {
+ return
+ }
+ logs := make([]*types.Log, 0)
+ for _, receipt := range reciepts {
+ logs = append(logs, receipt.Logs...)
+ }
+ b.blockChain.WriteBlockWithState(block, reciepts, logs, state, true)
+}
+
+func (b *Backend) segmentQueueRoutine() {
+ for {
+ select {
+ case tx := <-b.chanTxs:
+ b.txFeed.Send(core.NewTxsEvent{Txs: []*types.Transaction{tx}})
+ b.arbos.EnqueueSequencerTx(tx)
+ case <-b.chanNewBlock:
+ b.enqueueBlock(b.arbos.BuildBlock(true))
+ case <-b.chanClose:
+ return
+ }
+ }
+}
+
+//TODO: this is used when registering backend as lifecycle in stack
+func (b *Backend) Start() error {
+ return nil
+}
+
+func (b *Backend) Stop() error {
+
+ b.scope.Close()
+ b.blockChain.Stop()
+
+ return nil
+}