The following methods were created: eth_createAccessList, eth_coinbas…

…e, eth_getBlockReceipts, txpool_ContentFrom

jsonrpc/eth_endpoint.go

@@ -207,6 +207,37 @@ func (e *Eth) filterExtra(block *types.Block) error {
 	return nil
 }
 
+// CreateAccessList creates a EIP-2930 type AccessList for the given transaction.
+// Reexec and BlockNrOrHash can be specified to create the accessList on top of a certain state.
+func (e *Eth) CreateAccessList(arg *txnArgs, filter BlockNumberOrHash) (interface{}, error) {
+	header, err := GetHeaderFromBlockNumberOrHash(filter, e.store)
+	if err != nil {
+		return nil, err
+	}
+
+	transaction, err := DecodeTxn(arg, header.Number, e.store, true)
+	if err != nil {
+		return nil, err
+	}
+
+	res := &accessListResult{
+		Accesslist: transaction.AccessList(),
+		GasUsed:    argUint64(header.GasUsed),
+	}
+
+	return res, nil
+}
+
+// Returns the client coinbase address.
+func (e *Eth) Coinbase() (interface{}, error) {
+	h := e.store.Header()
+	if h == nil {
+		return nil, fmt.Errorf("header has a nil value")
+	}
+
+	return types.BytesToAddress(h.Miner), nil
+}
+
 // GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
 func (e *Eth) GetBlockTransactionCountByHash(blockHash types.Hash) (interface{}, error) {
 	block, ok := e.store.GetBlockByHash(blockHash, true)
@@ -410,6 +441,65 @@ func (e *Eth) GetTransactionReceipt(hash types.Hash) (interface{}, error) {
 	return toReceipt(raw, txn, uint64(txIndex), block.Header, logs), nil
 }
 
+// GetBlockReceipts returns all transaction receipts for a given block.
+func (e *Eth) GetBlockReceipts(number BlockNumber) (interface{}, error) {
+	num, err := GetNumericBlockNumber(number, e.store)
+	if err != nil {
+		return nil, err
+	}
+
+	block, ok := e.store.GetBlockByNumber(num, true)
+	if !ok {
+		return nil, nil
+	}
+
+	blockHash := block.Hash()
+	receipts, err := e.store.GetReceiptsByHash(blockHash)
+	if err != nil {
+		// block receipts not found
+		e.logger.Warn(
+			fmt.Sprintf("Receipts for block with hash [%s] not found", blockHash.String()),
+		)
+
+		return nil, nil
+	}
+
+	numberOfReceipts := len(receipts)
+	if numberOfReceipts == 0 {
+		// Receipts not written yet on the db
+		e.logger.Warn(
+			fmt.Sprintf("No receipts found for block with hash [%s]", blockHash.String()),
+		)
+
+		return nil, nil
+	}
+
+	if len(block.Transactions) == 0 {
+		e.logger.Warn(
+			fmt.Sprintf("No transations found for block with hash [%s]", blockHash.String()),
+		)
+
+		return nil, nil
+	}
+
+	if numberOfReceipts > len(block.Transactions) {
+		numberOfReceipts = len(block.Transactions)
+	}
+
+	var resReceipts []*receipt = make([]*receipt, numberOfReceipts)
+	logIndex := 0
+	for txIndex, txn := range block.Transactions {
+		raw := receipts[txIndex]
+		// accumulate receipt logs indexes from block transactions
+		// that are before the desired transaction
+		logIndex += len(receipts[txIndex].Logs)
+		logs := toLogs(raw.Logs, uint64(logIndex), uint64(txIndex), block.Header, raw.TxHash)
+		resReceipts[txIndex] = toReceipt(raw, txn, uint64(txIndex), block.Header, logs)
+	}
+
+	return resReceipts, nil
+}
+
 // GetStorageAt returns the contract storage at the index position
 func (e *Eth) GetStorageAt(
 	address types.Address,

jsonrpc/txpool_endpoint.go

@@ -29,6 +29,11 @@ type ContentResponse struct {
 	Queued  map[types.Address]map[uint64]*transaction `json:"queued"`
 }
 
+type ContentAddressResponse struct {
+	Pending map[uint64]*transaction `json:"pending"`
+	Queued  map[uint64]*transaction `json:"queued"`
+}
+
 type InspectResponse struct {
 	Pending         map[string]map[string]string `json:"pending"`
 	Queued          map[string]map[string]string `json:"queued"`
@@ -41,6 +46,37 @@ type StatusResponse struct {
 	Queued  uint64 `json:"queued"`
 }
 
+// ContentFrom returns the transactions contained within the transaction pool.
+func (t *TxPool) ContentFrom(addr types.Address) (interface{}, error) {
+	convertTxMap := func(txMap []*types.Transaction) map[uint64]*transaction {
+		result := make(map[uint64]*transaction, len(txMap))
+		for key, tx := range txMap {
+			result[uint64(key)] = toTransaction(tx, nil, &types.ZeroHash, nil)
+		}
+
+		return result
+	}
+
+	pendingTxs, queuedTxs := t.store.GetTxs(true)
+
+	pTxs, ok := pendingTxs[addr]
+	if !ok {
+		return nil, nil
+	}
+
+	qTxs, ok := queuedTxs[addr]
+	if !ok {
+		return nil, nil
+	}
+
+	resp := ContentAddressResponse{
+		Pending: convertTxMap(pTxs),
+		Queued:  convertTxMap(qTxs),
+	}
+
+	return resp, nil
+}
+
 // Create response for txpool_content request.
 // See https://geth.ethereum.org/docs/rpc/ns-txpool#txpool_content.
 func (t *TxPool) Content() (interface{}, error) {

jsonrpc/types.go

@@ -129,6 +129,11 @@ type header struct {
 	BaseFee         argUint64   `json:"baseFeePerGas,omitempty"`
 }
 
+type accessListResult struct {
+	Accesslist types.TxAccessList `json:"accessList"`
+	GasUsed    argUint64          `json:"gasUsed"`
+}
+
 type block struct {
 	ParentHash      types.Hash          `json:"parentHash"`
 	Sha3Uncles      types.Hash          `json:"sha3Uncles"`