erigon-pulse/cmd/rpcdaemon/commands/eth_txs.go

276 lines
8.4 KiB
Go
Raw Normal View History

package commands
import (
2021-05-04 05:51:28 +00:00
"bytes"
"context"
"math/big"
"github.com/ledgerwatch/erigon-lib/gointerfaces"
"github.com/ledgerwatch/erigon-lib/gointerfaces/txpool"
"github.com/ledgerwatch/erigon-lib/gointerfaces/types"
"github.com/ledgerwatch/erigon/common"
"github.com/ledgerwatch/erigon/common/hexutil"
"github.com/ledgerwatch/erigon/core/rawdb"
types2 "github.com/ledgerwatch/erigon/core/types"
"github.com/ledgerwatch/erigon/rlp"
"github.com/ledgerwatch/erigon/rpc"
"github.com/ledgerwatch/erigon/turbo/rpchelper"
)
// GetTransactionByHash implements eth_getTransactionByHash. Returns information about a transaction given the transaction's hash.
func (api *APIImpl) GetTransactionByHash(ctx context.Context, txnHash common.Hash) (*RPCTransaction, error) {
2021-04-03 06:26:00 +00:00
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
chainConfig, err := api.chainConfig(tx)
if err != nil {
return nil, err
}
// https://infura.io/docs/ethereum/json-rpc/eth-getTransactionByHash
blockNum, ok, err := api.txnLookup(ctx, tx, txnHash)
if err != nil {
return nil, err
}
if ok {
block, err := api.blockByNumberWithSenders(tx, blockNum)
if err != nil {
return nil, err
}
if block == nil {
return nil, nil
}
blockHash := block.Hash()
var txnIndex uint64
var txn types2.Transaction
for i, transaction := range block.Transactions() {
if transaction.Hash() == txnHash {
txn = transaction
txnIndex = uint64(i)
break
}
}
// Add GasPrice for the DynamicFeeTransaction
var baseFee *big.Int
if chainConfig.IsLondon(blockNum) && blockHash != (common.Hash{}) {
baseFee = block.BaseFee()
}
2022-03-07 03:24:21 +00:00
// if no transaction was found then we return nil
if txn == nil {
if chainConfig.Bor == nil {
return nil, nil
}
borTx, _, _, _ := rawdb.ReadBorTransactionForBlock(tx, block)
if borTx == nil {
return nil, nil
}
return newRPCBorTransaction(borTx, txnHash, blockHash, blockNum, uint64(len(block.Transactions())), baseFee), nil
}
2022-03-07 03:24:21 +00:00
return newRPCTransaction(txn, blockHash, blockNum, txnIndex, baseFee), nil
2021-05-04 05:51:28 +00:00
}
2021-07-22 14:21:55 +00:00
curHeader := rawdb.ReadCurrentHeader(tx)
2021-10-20 00:28:14 +00:00
if curHeader == nil {
return nil, nil
}
2021-07-22 14:21:55 +00:00
2021-05-04 05:51:28 +00:00
// No finalized transaction, try to retrieve it from the pool
reply, err := api.txPool.Transactions(ctx, &txpool.TransactionsRequest{Hashes: []*types.H256{gointerfaces.ConvertHashToH256(txnHash)}})
2021-05-04 05:51:28 +00:00
if err != nil {
return nil, err
}
if len(reply.RlpTxs[0]) > 0 {
s := rlp.NewStream(bytes.NewReader(reply.RlpTxs[0]), uint64(len(reply.RlpTxs[0])))
txn, err := types2.DecodeTransaction(s)
2021-05-04 05:51:28 +00:00
if err != nil {
return nil, err
}
2022-03-07 03:24:21 +00:00
// if no transaction was found in the txpool then we return nil and an error warning that we didn't find the transaction by the hash
if txn == nil {
return nil, nil
}
2021-07-22 14:21:55 +00:00
return newRPCPendingTransaction(txn, curHeader, chainConfig), nil
2021-05-04 05:51:28 +00:00
}
// Transaction unknown, return as such
return nil, nil
}
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
func (api *APIImpl) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
// https://infura.io/docs/ethereum/json-rpc/eth-getTransactionByHash
blockNum, ok, err := api.txnLookup(ctx, tx, hash)
if err != nil {
return nil, err
}
if !ok {
return nil, nil
}
block, err := api.blockByNumberWithSenders(tx, blockNum)
if err != nil {
return nil, err
}
if block == nil {
return nil, nil
}
var txn types2.Transaction
for _, transaction := range block.Transactions() {
if transaction.Hash() == hash {
txn = transaction
break
}
}
if txn != nil {
2021-05-04 05:51:28 +00:00
var buf bytes.Buffer
err = txn.MarshalBinary(&buf)
return buf.Bytes(), err
}
// No finalized transaction, try to retrieve it from the pool
reply, err := api.txPool.Transactions(ctx, &txpool.TransactionsRequest{Hashes: []*types.H256{gointerfaces.ConvertHashToH256(hash)}})
if err != nil {
return nil, err
}
if len(reply.RlpTxs[0]) > 0 {
2021-05-04 05:51:28 +00:00
return reply.RlpTxs[0], nil
}
return nil, nil
}
// GetTransactionByBlockHashAndIndex implements eth_getTransactionByBlockHashAndIndex. Returns information about a transaction given the block's hash and a transaction index.
func (api *APIImpl) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, txIndex hexutil.Uint64) (*RPCTransaction, error) {
2021-04-03 06:26:00 +00:00
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
chainConfig, err := api.chainConfig(tx)
if err != nil {
return nil, err
}
// https://infura.io/docs/ethereum/json-rpc/eth-getTransactionByBlockHashAndIndex
2021-09-29 06:51:51 +00:00
block, err := api.blockByHashWithSenders(tx, blockHash)
if err != nil {
return nil, err
}
if block == nil {
return nil, nil // not error, see https://github.com/ledgerwatch/erigon/issues/1645
}
txs := block.Transactions()
if uint64(txIndex) > uint64(len(txs)) {
return nil, nil // not error
} else if uint64(txIndex) == uint64(len(txs)) {
if chainConfig.Bor == nil {
return nil, nil // not error
}
borTx, _, _, _ := rawdb.ReadBorTransactionForBlock(tx, block)
if borTx == nil {
return nil, nil // not error
}
derivedBorTxHash := types2.ComputeBorTxHash(block.NumberU64(), block.Hash())
return newRPCBorTransaction(borTx, derivedBorTxHash, block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee()), nil
}
return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee()), nil
}
2021-05-04 05:51:28 +00:00
// GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
func (api *APIImpl) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (hexutil.Bytes, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
// https://infura.io/docs/ethereum/json-rpc/eth-getRawTransactionByBlockHashAndIndex
2021-09-29 06:51:51 +00:00
block, err := api.blockByHashWithSenders(tx, blockHash)
2021-05-04 05:51:28 +00:00
if err != nil {
return nil, err
}
if block == nil {
return nil, nil // not error, see https://github.com/ledgerwatch/erigon/issues/1645
2021-05-04 05:51:28 +00:00
}
return newRPCRawTransactionFromBlockIndex(block, uint64(index))
}
// GetTransactionByBlockNumberAndIndex implements eth_getTransactionByBlockNumberAndIndex. Returns information about a transaction given a block number and transaction index.
func (api *APIImpl) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, txIndex hexutil.Uint) (*RPCTransaction, error) {
2021-04-03 06:26:00 +00:00
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
chainConfig, err := api.chainConfig(tx)
if err != nil {
return nil, err
}
// https://infura.io/docs/ethereum/json-rpc/eth-getTransactionByBlockNumberAndIndex
blockNum, _, _, err := rpchelper.GetBlockNumber(rpc.BlockNumberOrHashWithNumber(blockNr), tx, api.filters)
if err != nil {
return nil, err
}
2021-09-29 06:51:51 +00:00
block, err := api.blockByNumberWithSenders(tx, blockNum)
if err != nil {
return nil, err
}
if block == nil {
return nil, nil // not error, see https://github.com/ledgerwatch/erigon/issues/1645
}
txs := block.Transactions()
if uint64(txIndex) > uint64(len(txs)) {
return nil, nil // not error
} else if uint64(txIndex) == uint64(len(txs)) {
if chainConfig.Bor == nil {
return nil, nil // not error
}
borTx, _, _, _ := rawdb.ReadBorTransactionForBlock(tx, block)
if borTx == nil {
return nil, nil
}
derivedBorTxHash := types2.ComputeBorTxHash(block.NumberU64(), block.Hash())
return newRPCBorTransaction(borTx, derivedBorTxHash, block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee()), nil
}
return newRPCTransaction(txs[txIndex], block.Hash(), block.NumberU64(), uint64(txIndex), block.BaseFee()), nil
}
2021-05-04 05:51:28 +00:00
// GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
func (api *APIImpl) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (hexutil.Bytes, error) {
tx, err := api.db.BeginRo(ctx)
if err != nil {
return nil, err
}
defer tx.Rollback()
// https://infura.io/docs/ethereum/json-rpc/eth-getRawTransactionByBlockNumberAndIndex
2021-09-29 06:51:51 +00:00
block, err := api.blockByRPCNumber(blockNr, tx)
2021-05-04 05:51:28 +00:00
if err != nil {
return nil, err
}
if block == nil {
return nil, nil // not error, see https://github.com/ledgerwatch/erigon/issues/1645
2021-05-04 05:51:28 +00:00
}
return newRPCRawTransactionFromBlockIndex(block, uint64(index))
}