gitlab.com/aquachain/aquachain@v1.17.16-rc3.0.20221018032414-e3ddf1e1c055/aqua/api_backend.go (about)

     1  // Copyright 2018 The aquachain Authors
     2  // This file is part of the aquachain library.
     3  //
     4  // The aquachain library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The aquachain library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the aquachain library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package aqua
    18  
    19  import (
    20  	"context"
    21  	"math/big"
    22  
    23  	"gitlab.com/aquachain/aquachain"
    24  	"gitlab.com/aquachain/aquachain/aqua/accounts"
    25  	"gitlab.com/aquachain/aquachain/aqua/downloader"
    26  	"gitlab.com/aquachain/aquachain/aqua/event"
    27  	"gitlab.com/aquachain/aquachain/aqua/gasprice"
    28  	"gitlab.com/aquachain/aquachain/aquadb"
    29  	"gitlab.com/aquachain/aquachain/common"
    30  	"gitlab.com/aquachain/aquachain/common/math"
    31  	"gitlab.com/aquachain/aquachain/core"
    32  	"gitlab.com/aquachain/aquachain/core/bloombits"
    33  	"gitlab.com/aquachain/aquachain/core/state"
    34  	"gitlab.com/aquachain/aquachain/core/types"
    35  	"gitlab.com/aquachain/aquachain/core/vm"
    36  	"gitlab.com/aquachain/aquachain/params"
    37  	"gitlab.com/aquachain/aquachain/rpc"
    38  )
    39  
    40  // AquaApiBackend implements aquaapi.Backend for full nodes
    41  type AquaApiBackend struct {
    42  	aqua *Aquachain
    43  	gpo  *gasprice.Oracle
    44  }
    45  
    46  func (b *AquaApiBackend) SyncProgress() aquachain.SyncProgress {
    47  	return b.aqua.Downloader().Progress()
    48  }
    49  func (b *AquaApiBackend) ChainConfig() *params.ChainConfig {
    50  	return b.aqua.chainConfig
    51  }
    52  func (b *AquaApiBackend) GetHeaderVersion(height *big.Int) params.HeaderVersion {
    53  	return b.aqua.chainConfig.GetBlockVersion(height)
    54  }
    55  
    56  func (b *AquaApiBackend) CurrentBlock() *types.Block {
    57  	return b.aqua.blockchain.CurrentBlock()
    58  }
    59  
    60  func (b *AquaApiBackend) SetHead(number uint64) {
    61  	if b.aqua.protocolManager != nil {
    62  		b.aqua.protocolManager.downloader.Cancel()
    63  	}
    64  	b.aqua.blockchain.SetHead(number)
    65  }
    66  
    67  func (b *AquaApiBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) {
    68  	// Pending block is only known by the miner
    69  	if blockNr == rpc.PendingBlockNumber {
    70  		block := b.aqua.miner.PendingBlock()
    71  		return block.Header(), nil
    72  	}
    73  	// Otherwise resolve and return the block
    74  	if blockNr == rpc.LatestBlockNumber {
    75  		return b.aqua.blockchain.CurrentBlock().Header(), nil
    76  	}
    77  	return b.aqua.blockchain.GetHeaderByNumber(uint64(blockNr)), nil
    78  }
    79  
    80  func (b *AquaApiBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error) {
    81  	// Pending block is only known by the miner
    82  	if blockNr == rpc.PendingBlockNumber {
    83  		block := b.aqua.miner.PendingBlock()
    84  		return block, nil
    85  	}
    86  	// Otherwise resolve and return the block
    87  	if blockNr == rpc.LatestBlockNumber {
    88  		return b.aqua.blockchain.CurrentBlock(), nil
    89  	}
    90  	return b.aqua.blockchain.GetBlockByNumber(uint64(blockNr)), nil
    91  }
    92  
    93  func (b *AquaApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
    94  	// Pending state is only known by the miner
    95  	if blockNr == rpc.PendingBlockNumber {
    96  		block, state := b.aqua.miner.Pending()
    97  		return state, block.Header(), nil
    98  	}
    99  	// Otherwise resolve the block number and return its state
   100  	header, err := b.HeaderByNumber(ctx, blockNr)
   101  	if header == nil || err != nil {
   102  		return nil, nil, err
   103  	}
   104  	stateDb, err := b.aqua.BlockChain().StateAt(header.Root)
   105  	return stateDb, header, err
   106  }
   107  
   108  func (b *AquaApiBackend) GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error) {
   109  	return b.aqua.blockchain.GetBlockByHash(blockHash), nil
   110  }
   111  
   112  func (b *AquaApiBackend) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) {
   113  	return core.GetBlockReceipts(b.aqua.chainDb, blockHash, core.GetBlockNumber(b.aqua.chainDb, blockHash)), nil
   114  }
   115  
   116  func (b *AquaApiBackend) GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error) {
   117  	receipts := core.GetBlockReceipts(b.aqua.chainDb, blockHash, core.GetBlockNumber(b.aqua.chainDb, blockHash))
   118  	if receipts == nil {
   119  		return nil, nil
   120  	}
   121  	logs := make([][]*types.Log, len(receipts))
   122  	for i, receipt := range receipts {
   123  		logs[i] = receipt.Logs
   124  	}
   125  	return logs, nil
   126  }
   127  
   128  func (b *AquaApiBackend) GetTd(blockHash common.Hash) *big.Int {
   129  	return b.aqua.blockchain.GetTdByHash(blockHash)
   130  }
   131  
   132  func (b *AquaApiBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) {
   133  	state.SetBalance(msg.From(), math.MaxBig256)
   134  	vmError := func() error { return nil }
   135  
   136  	context := core.NewEVMContext(msg, header, b.aqua.BlockChain(), nil)
   137  	return vm.NewEVM(context, state, b.aqua.chainConfig, vmCfg), vmError, nil
   138  }
   139  
   140  func (b *AquaApiBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
   141  	return b.aqua.BlockChain().SubscribeRemovedLogsEvent(ch)
   142  }
   143  
   144  func (b *AquaApiBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
   145  	return b.aqua.BlockChain().SubscribeChainEvent(ch)
   146  }
   147  
   148  func (b *AquaApiBackend) SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription {
   149  	return b.aqua.BlockChain().SubscribeChainHeadEvent(ch)
   150  }
   151  
   152  func (b *AquaApiBackend) SubscribeChainSideEvent(ch chan<- core.ChainSideEvent) event.Subscription {
   153  	return b.aqua.BlockChain().SubscribeChainSideEvent(ch)
   154  }
   155  
   156  func (b *AquaApiBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
   157  	return b.aqua.BlockChain().SubscribeLogsEvent(ch)
   158  }
   159  
   160  func (b *AquaApiBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
   161  	return b.aqua.txPool.AddLocal(signedTx)
   162  }
   163  
   164  func (b *AquaApiBackend) GetPoolTransactions() (types.Transactions, error) {
   165  	pending, err := b.aqua.txPool.Pending()
   166  	if err != nil {
   167  		return nil, err
   168  	}
   169  	var txs types.Transactions
   170  	for _, batch := range pending {
   171  		txs = append(txs, batch...)
   172  	}
   173  	return txs, nil
   174  }
   175  
   176  func (b *AquaApiBackend) GetPoolTransaction(hash common.Hash) *types.Transaction {
   177  	return b.aqua.txPool.Get(hash)
   178  }
   179  
   180  func (b *AquaApiBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) {
   181  	return b.aqua.txPool.State().GetNonce(addr), nil
   182  }
   183  
   184  func (b *AquaApiBackend) Stats() (pending int, queued int) {
   185  	return b.aqua.txPool.Stats()
   186  }
   187  
   188  func (b *AquaApiBackend) TxPoolContent() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
   189  	return b.aqua.TxPool().Content()
   190  }
   191  
   192  func (b *AquaApiBackend) SubscribeTxPreEvent(ch chan<- core.TxPreEvent) event.Subscription {
   193  	return b.aqua.TxPool().SubscribeTxPreEvent(ch)
   194  }
   195  
   196  func (b *AquaApiBackend) Downloader() *downloader.Downloader {
   197  	return b.aqua.Downloader()
   198  }
   199  
   200  func (b *AquaApiBackend) ProtocolVersion() int {
   201  	return b.aqua.AquaVersion()
   202  }
   203  
   204  func (b *AquaApiBackend) SuggestPrice(ctx context.Context) (*big.Int, error) {
   205  	return b.gpo.SuggestPrice(ctx)
   206  }
   207  
   208  func (b *AquaApiBackend) ChainDb() aquadb.Database {
   209  	return b.aqua.ChainDb()
   210  }
   211  
   212  func (b *AquaApiBackend) EventMux() *event.TypeMux {
   213  	return b.aqua.EventMux()
   214  }
   215  
   216  func (b *AquaApiBackend) AccountManager() *accounts.Manager {
   217  	return b.aqua.AccountManager()
   218  }
   219  
   220  func (b *AquaApiBackend) BloomStatus() (uint64, uint64) {
   221  	sections, _, _ := b.aqua.bloomIndexer.Sections()
   222  	return params.BloomBitsBlocks, sections
   223  }
   224  
   225  func (b *AquaApiBackend) ServiceFilter(ctx context.Context, session *bloombits.MatcherSession) {
   226  	for i := 0; i < bloomFilterThreads; i++ {
   227  		go session.Multiplex(bloomRetrievalBatch, bloomRetrievalWait, b.aqua.bloomRequests)
   228  	}
   229  }