Add mempool enpoints

api/api.go

@@ -46,6 +46,7 @@ type Config struct {
 	AllowedTracers    []string
 	SoloMode          bool
 	EnableDeprecated  bool
+	EnableTxpool      bool
 }
 
 // New return api router
@@ -92,8 +93,8 @@ func New(
 		Mount(router, "/transactions")
 	debug.New(repo, stater, forkConfig, config.CallGasLimit, config.AllowCustomTracer, bft, config.AllowedTracers, config.SoloMode).
 		Mount(router, "/debug")
-	node.New(nw).
-		Mount(router, "/node")
+	node.New(nw, txPool).
+		Mount(router, "/node", config.EnableTxpool)
 	subs := subscriptions.New(repo, origins, config.BacktraceLimit, txPool, config.EnableDeprecated)
 	subs.Mount(router, "/subscriptions")
 

api/doc/thor.yaml

@@ -394,6 +394,65 @@ paths:
               schema:
                 $ref: '#/components/schemas/GetPeersResponse'
 
+  /node/txpool:
+    get:
+      tags:
+        - Node
+      summary: Retrieve transactions from transactions pool
+      description: |
+        Retrieve transactions that are currently in the txpool (pending transactions). 
+        The response can be filtered by sender (origin) addresses.
+
+        The transactions can be returned either as a list of transaction IDs or as expanded transaction objects.
+      parameters:
+        - name: expanded
+          in: query
+          description: |
+            Whether to return expanded transaction details (true) or just transaction IDs (false).
+            If omitted, defaults to false.
+          required: false
+          schema:
+            type: boolean
+        - name: origin
+          in: query
+          description: |
+            Filter transactions by sender address.
+          required: false
+          schema:
+            type: string
+            pattern: '^0x[0-9a-fA-F]{40}$'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                oneOf:
+                  - $ref: '#/components/schemas/TransactionsIDs'
+                  - $ref: '#/components/schemas/Transactions'
+        '400':
+          description: Bad Request
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: 'Invalid address'
+
+  /node/txpool/status:
+    get:
+      tags:
+        - Node 
+      summary: Get txpool status
+      description: |
+        Retrieve the current status of the txpool, including the number of pending transactions.
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Status'
+
   /subscriptions/block:
     get:
       tags:
@@ -2255,6 +2314,37 @@ components:
           example: false
           nullable: false
 
+    Status:
+      type: object
+      title: Status
+      properties:
+        total:
+          type: integer
+          format: uint
+          description: The total number of transactions currently in the txpool
+          example: 42
+          nullable: false
+
+    TransactionsIDs:
+      type: array
+      title: TransactionsIDs  
+      name: TransactionsIDs
+      description: Array of transaction IDs currently in the txpool
+      items:
+        type: string
+        format: hex
+        pattern: '^0x[0-9a-f]{64}$'
+      example:
+        - '0x284bba50ef777889ff1a367ed0b38d5e5626714477c40de38d71cedd6f9fa477'
+        - '0x4de71f2d588aa8a1ea00fe8312d92966da424d9939a511fc0be81e65fad52af8'
+
+    Transactions:
+      type: array 
+      title: Transactions
+      description: Array of expanded transaction objects currently in the txpool
+      items:
+        $ref: '#/components/schemas/Tx'
+
   parameters:
     GetAddressInPath:
       name: address

api/node/node.go

@@ -8,16 +8,25 @@ package node
 import (
 	"net/http"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+	"github.com/vechain/thor/v2/api/transactions"
 	"github.com/vechain/thor/v2/api/utils"
+	"github.com/vechain/thor/v2/thor"
+	"github.com/vechain/thor/v2/tx"
+	"github.com/vechain/thor/v2/txpool"
 )
 
 type Node struct {
-	nw Network
+	pool *txpool.TxPool
+	nw   Network
 }
 
-func New(nw Network) *Node {
+func New(nw Network, pool *txpool.TxPool) *Node {
 	return &Node{
+		pool,
 		nw,
 	}
 }
@@ -30,11 +39,112 @@ func (n *Node) handleNetwork(w http.ResponseWriter, _ *http.Request) error {
 	return utils.WriteJSON(w, n.PeersStats())
 }
 
-func (n *Node) Mount(root *mux.Router, pathPrefix string) {
+func filterTransactions(origin *thor.Address, allTransactions tx.Transactions) (tx.Transactions, error) {
+	var filtered []*tx.Transaction
+
+	for _, tx := range allTransactions {
+		sender, err := tx.Origin()
+		if err != nil {
+			return nil, utils.BadRequest(errors.WithMessage(err, "filtering origin"))
+		}
+		if origin != nil && sender == *origin {
+			filtered = append(filtered, tx)
+		}
+	}
+
+	return filtered, nil
+}
+
+func (m *Node) handleGetTransactions(w http.ResponseWriter, req *http.Request) error {
+	expanded, err := utils.StringToBoolean(req.URL.Query().Get("expanded"), false)
+	if err != nil {
+		return utils.BadRequest(errors.WithMessage(err, "expanded"))
+	}
+
+	originString := req.URL.Query().Get("origin")
+	origin, err := utils.StringToAddress(originString)
+	if err != nil {
+		return utils.BadRequest(errors.WithMessage(err, "origin"))
+	}
+
+	var filteredTransactions tx.Transactions
+	if origin == nil {
+		filteredTransactions = m.pool.Dump()
+	} else {
+		filtered, err := filterTransactions(origin, m.pool.Dump())
+		if err != nil {
+			return utils.BadRequest(err)
+		}
+		filteredTransactions = filtered
+	}
+
+	if expanded {
+		trxs := make([]transactions.Transaction, len(filteredTransactions))
+		for index, tx := range filteredTransactions {
+			origin, _ := tx.Origin()
+			delegator, _ := tx.Delegator()
+
+			txClauses := tx.Clauses()
+			cls := make(transactions.Clauses, len(txClauses))
+			for i, c := range txClauses {
+				cls[i] = transactions.Clause{
+					To:    c.To(),
+					Value: math.HexOrDecimal256(*c.Value()),
+					Data:  hexutil.Encode(c.Data()),
+				}
+			}
+			br := tx.BlockRef()
+			trxs[index] = transactions.Transaction{
+				ChainTag:     tx.ChainTag(),
+				ID:           tx.ID(),
+				Origin:       origin,
+				BlockRef:     hexutil.Encode(br[:]),
+				Expiration:   tx.Expiration(),
+				Nonce:        math.HexOrDecimal64(tx.Nonce()),
+				Size:         uint32(tx.Size()),
+				GasPriceCoef: tx.GasPriceCoef(),
+				Gas:          tx.Gas(),
+				DependsOn:    tx.DependsOn(),
+				Clauses:      cls,
+				Delegator:    delegator,
+			}
+		}
+
+		return utils.WriteJSON(w, trxs)
+	}
+
+	transactions := make([]thor.Bytes32, len(filteredTransactions))
+	for index, tx := range filteredTransactions {
+		transactions[index] = tx.ID()
+	}
+
+	return utils.WriteJSON(w, transactions)
+}
+
+func (m *Node) handleGetTxpoolStatus(w http.ResponseWriter, req *http.Request) error {
+	total := m.pool.Len()
+	status := Status{
+		Total: uint(total),
+	}
+	return utils.WriteJSON(w, status)
+}
+
+func (n *Node) Mount(root *mux.Router, pathPrefix string, enableTxpool bool) {
 	sub := root.PathPrefix(pathPrefix).Subrouter()
 
 	sub.Path("/network/peers").
 		Methods(http.MethodGet).
 		Name("GET /node/network/peers").
 		HandlerFunc(utils.WrapHandlerFunc(n.handleNetwork))
+
+	if enableTxpool {
+		sub.Path("/txpool").
+			Methods(http.MethodGet).
+			Name("GET /node/txpool").
+			HandlerFunc(utils.WrapHandlerFunc(n.handleGetTransactions))
+		sub.Path("/txpool/status").
+			Methods(http.MethodGet).
+			Name("GET /node/txpool/status").
+			HandlerFunc(utils.WrapHandlerFunc(n.handleGetTxpoolStatus))
+	}
 }

api/node/node_test.go

@@ -5,6 +5,7 @@
 package node_test
 
 import (
+	"encoding/json"
 	"net/http/httptest"
 	"testing"
 	"time"
@@ -13,27 +14,62 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/vechain/thor/v2/api/node"
+	"github.com/vechain/thor/v2/api/transactions"
 	"github.com/vechain/thor/v2/comm"
+	"github.com/vechain/thor/v2/genesis"
+	"github.com/vechain/thor/v2/tx"
+
 	"github.com/vechain/thor/v2/test/testchain"
 	"github.com/vechain/thor/v2/thorclient"
 	"github.com/vechain/thor/v2/txpool"
 )
 
-var ts *httptest.Server
+var (
+	ts      *httptest.Server
+	tclient *thorclient.Client
+	pool    *txpool.TxPool
+)
 
 func TestNode(t *testing.T) {
 	initCommServer(t)
-	tclient := thorclient.New(ts.URL)
+	tclient = thorclient.New(ts.URL)
 
 	peersStats, err := tclient.Peers()
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(peersStats), "count should be zero")
+
+	t.Run("getTransactions", testGetTransactions)
+	t.Run("getTransactionsExpanded", testGetTransactionsExpanded)
+	t.Run("getTransactionsWithOrigin", testGetTransactionsWithOrigin)
+	t.Run("getTransactionsWithBadExpanded", testGetTransactionsWithBadExpanded)
+	t.Run("getTransactionsWithBadOrigin", testGetTransactionsWithBadOrigin)
 }
 
 func initCommServer(t *testing.T) {
 	thorChain, err := testchain.NewIntegrationTestChain()
 	require.NoError(t, err)
 
+	chainTag := thorChain.Repo().ChainTag()
+
+	pool = txpool.New(thorChain.Repo(), thorChain.Stater(), txpool.Options{
+		Limit:           10000,
+		LimitPerAccount: 16,
+		MaxLifetime:     10 * time.Minute,
+	})
+
+	for i := range 3 {
+		transaction := new(tx.Builder).
+			Clause(tx.NewClause(&genesis.DevAccounts()[1].Address)).
+			ChainTag(chainTag).
+			Expiration(10).
+			Gas(21000).
+			Nonce(uint64(i)).
+			Build()
+		transaction = tx.MustSign(transaction, genesis.DevAccounts()[0].PrivateKey)
+		err := pool.Add(transaction)
+		require.NoError(t, err)
+	}
+
 	communicator := comm.New(
 		thorChain.Repo(),
 		txpool.New(thorChain.Repo(), thorChain.Stater(), txpool.Options{
@@ -44,7 +80,50 @@ func initCommServer(t *testing.T) {
 	)
 
 	router := mux.NewRouter()
-	node.New(communicator).Mount(router, "/node")
+	node.New(communicator, pool).Mount(router, "/node", true)
 
 	ts = httptest.NewServer(router)
 }
+
+func httpGetAndCheckResponseStatus(t *testing.T, url string, responseStatusCode int) []byte {
+	body, statusCode, err := tclient.RawHTTPClient().RawHTTPGet(url)
+	require.NoError(t, err)
+	assert.Equal(t, responseStatusCode, statusCode)
+	return body
+}
+
+func testGetTransactions(t *testing.T) {
+	res := httpGetAndCheckResponseStatus(t, "/node/txpool", 200)
+	var txResponse []string
+	err := json.Unmarshal(res, &txResponse)
+	require.NoError(t, err)
+	assert.NotNil(t, txResponse)
+	assert.True(t, len(txResponse) > 0)
+}
+
+func testGetTransactionsExpanded(t *testing.T) {
+	res := httpGetAndCheckResponseStatus(t, "/node/txpool?expanded=true", 200)
+	var txResponse []transactions.Transaction
+	err := json.Unmarshal(res, &txResponse)
+	require.NoError(t, err)
+	assert.NotNil(t, txResponse)
+	assert.True(t, len(txResponse) > 0)
+}
+
+func testGetTransactionsWithOrigin(t *testing.T) {
+	acc := genesis.DevAccounts()[0]
+	res := httpGetAndCheckResponseStatus(t, "/node/txpool?origin="+acc.Address.String(), 200)
+	var txResponse []string
+	err := json.Unmarshal(res, &txResponse)
+	require.NoError(t, err)
+	assert.NotNil(t, txResponse)
+	assert.True(t, len(txResponse) > 0)
+}
+
+func testGetTransactionsWithBadExpanded(t *testing.T) {
+	httpGetAndCheckResponseStatus(t, "/node/txpool?expanded=notboolean", 400)
+}
+
+func testGetTransactionsWithBadOrigin(t *testing.T) {
+	httpGetAndCheckResponseStatus(t, "/node/txpool?origin=0xinvalid", 400)
+}