feat(onboarding): Add rpc endpoint juno_getBlockWithTxnHashesAndReceipts

rpc/block.go

@@ -154,6 +154,13 @@ type BlockWithReceipts struct {
 	Transactions []TransactionWithReceipt `json:"transactions"`
 }
 
+type BlockWithTxHashesAndReceipts struct {
+	Status BlockStatus `json:"status,omitempty"`
+	BlockHeader
+	TxnHashes    []*felt.Felt             `json:"transactions_hashes"`
+	Transactions []TransactionWithReceipt `json:"transactions_with_receipts"`
+}
+
 /****************************************************
 		Block Handlers
 *****************************************************/
@@ -205,7 +212,7 @@ func (h *Handler) BlockWithTxHashes(id BlockID) (*BlockWithTxHashes, *jsonrpc.Er
 
 	return &BlockWithTxHashes{
 		Status:      status,
-		BlockHeader: adaptBlockHeader(block.Header),
+		BlockHeader: AdaptBlockHeader(block.Header),
 		TxnHashes:   txnHashes,
 	}, nil
 }
@@ -254,11 +261,34 @@ func (h *Handler) BlockWithReceipts(id BlockID) (*BlockWithReceipts, *jsonrpc.Er
 
 	return &BlockWithReceipts{
 		Status:       blockStatus,
-		BlockHeader:  adaptBlockHeader(block.Header),
+		BlockHeader:  AdaptBlockHeader(block.Header),
 		Transactions: txsWithReceipts,
 	}, nil
 }
 
+func (h *Handler) BlockWithTxHashesAndReceipts(id BlockID) (*BlockWithTxHashesAndReceipts, *jsonrpc.Error) {
+	// Get tx receipts
+	block, err := h.BlockWithReceipts(id)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get tx hashes
+	txnHashes := make([]*felt.Felt, len(block.Transactions))
+	for index, txn := range block.Transactions {
+		// Get hash from Receipt and not Transaction as `starknet_getBlockWithReceipts`'s
+		// array of txs does not contain hash
+		txnHashes[index] = txn.Receipt.Hash
+	}
+
+	return &BlockWithTxHashesAndReceipts{
+		Status:       block.Status,
+		BlockHeader:  block.BlockHeader,
+		Transactions: block.Transactions,
+		TxnHashes:    txnHashes,
+	}, nil
+}
+
 // BlockWithTxs returns the block information with full transactions given a block ID.
 //
 // It follows the specification defined here:
@@ -281,7 +311,7 @@ func (h *Handler) BlockWithTxs(id BlockID) (*BlockWithTxs, *jsonrpc.Error) {
 
 	return &BlockWithTxs{
 		Status:       status,
-		BlockHeader:  adaptBlockHeader(block.Header),
+		BlockHeader:  AdaptBlockHeader(block.Header),
 		Transactions: txs,
 	}, nil
 }
@@ -302,7 +332,7 @@ func (h *Handler) blockStatus(id BlockID, block *core.Block) (BlockStatus, *json
 	return status, nil
 }
 
-func adaptBlockHeader(header *core.Header) BlockHeader {
+func AdaptBlockHeader(header *core.Header) BlockHeader {
 	var blockNumber *uint64
 	// if header.Hash == nil it's a pending block
 	if header.Hash != nil {

rpc/block_test.go

@@ -703,6 +703,127 @@ func TestBlockWithReceipts(t *testing.T) {
 	})
 }
 
+func TestBlockWithTxHashesAndReceipts(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+
+	var mockSyncReader *mocks.MockSyncReader
+
+	mockReader := mocks.NewMockReader(mockCtrl)
+	mockSyncReader = mocks.NewMockSyncReader(mockCtrl)
+
+	n := utils.Ptr(utils.Sepolia)
+	handler := rpc.New(mockReader, mockSyncReader, nil, "", nil)
+
+	client := feeder.NewTestClient(t, n)
+	gw := adaptfeeder.New(client)
+
+	latestBlockNumber := uint64(56377)
+	latestBlock, err := gw.BlockByNumber(context.Background(), latestBlockNumber)
+	require.NoError(t, err)
+
+	// Helper function to assert actual returned block against expected one
+	assertBlock := func(t *testing.T, b *rpc.BlockWithTxHashesAndReceipts, blockStatus rpc.BlockStatus, txFinalityStatus rpc.TxnFinalityStatus) {
+		t.Helper()
+
+		// Assert block status
+		assert.Equal(t, blockStatus, b.Status)
+
+		// Assert block header
+		assert.Equal(t, rpc.AdaptBlockHeader(latestBlock.Header), b.BlockHeader)
+
+		// Assert transaction hashes
+		assert.Equal(t, len(latestBlock.Transactions), len(b.TxnHashes))
+		for i := range latestBlock.Transactions {
+			assert.Equal(t, latestBlock.Transactions[i].Hash(), b.TxnHashes[i])
+		}
+
+		// Build receipts from expected block
+		var txsWithReceipt []rpc.TransactionWithReceipt
+		for i, tx := range latestBlock.Transactions {
+			receipt := latestBlock.Receipts[i]
+			adaptedTx := rpc.AdaptTransaction(tx)
+			adaptedTx.Hash = nil
+
+			txsWithReceipt = append(txsWithReceipt, rpc.TransactionWithReceipt{
+				Transaction: adaptedTx,
+				Receipt:     rpc.AdaptReceipt(receipt, tx, txFinalityStatus, nil, 0),
+			})
+		}
+		// Assert receipts
+		assert.Equal(t, txsWithReceipt, b.Transactions)
+	}
+
+	t.Run("block not found", func(t *testing.T) {
+		mockReader.EXPECT().BlockByNumber(latestBlock.Number).Return(nil, db.ErrKeyNotFound)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Number: latestBlock.Number})
+
+		require.Nil(t, block)
+		require.Equal(t, rpc.ErrBlockNotFound, rpcErr)
+	})
+
+	t.Run("L1Head failure", func(t *testing.T) {
+		expectedError := errors.New("L1Head failure")
+
+		mockReader.EXPECT().BlockByHash(latestBlock.Hash).Return(latestBlock, nil)
+		mockReader.EXPECT().L1Head().Return(nil, expectedError)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Hash: latestBlock.Hash})
+
+		require.Nil(t, block)
+		require.Equal(t, rpc.ErrInternal.CloneWithData(expectedError.Error()), rpcErr)
+	})
+
+	t.Run("blockID - latest", func(t *testing.T) {
+		mockReader.EXPECT().Head().Return(latestBlock, nil)
+		mockReader.EXPECT().L1Head().Return(nil, nil)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Latest: true})
+
+		require.Nil(t, rpcErr)
+		assertBlock(t, block, rpc.BlockAcceptedL2, rpc.TxnAcceptedOnL2)
+	})
+
+	t.Run("blockID - hash", func(t *testing.T) {
+		mockReader.EXPECT().BlockByHash(latestBlock.Hash).Return(latestBlock, nil)
+		mockReader.EXPECT().L1Head().Return(nil, nil)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Hash: latestBlock.Hash})
+
+		require.Nil(t, rpcErr)
+		assertBlock(t, block, rpc.BlockAcceptedL2, rpc.TxnAcceptedOnL2)
+	})
+
+	t.Run("blockID - pending", func(t *testing.T) {
+		mockSyncReader.EXPECT().Pending().Return(
+			&sync.Pending{Block: latestBlock},
+			nil,
+		)
+		mockReader.EXPECT().L1Head().Return(nil, nil)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Pending: true})
+
+		require.Nil(t, rpcErr)
+		assertBlock(t, block, rpc.BlockPending, rpc.TxnAcceptedOnL2)
+	})
+
+	t.Run("blockID - number accepted on l1", func(t *testing.T) {
+		mockReader.EXPECT().BlockByNumber(latestBlock.Number).Return(latestBlock, nil)
+		mockReader.EXPECT().L1Head().Return(
+			&core.L1Head{
+				BlockNumber: latestBlock.Number,
+			},
+			nil,
+		)
+
+		block, rpcErr := handler.BlockWithTxHashesAndReceipts(rpc.BlockID{Number: latestBlockNumber})
+
+		require.Nil(t, rpcErr)
+		assertBlock(t, block, rpc.BlockAcceptedL1, rpc.TxnAcceptedOnL1)
+	})
+}
+
 func TestRpcBlockAdaptation(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	t.Cleanup(mockCtrl.Finish)

rpc/handlers.go

@@ -404,6 +404,11 @@ func (h *Handler) Methods() ([]jsonrpc.Method, string) { //nolint: funlen
 			Params:  []jsonrpc.Parameter{{Name: "transaction_hash"}},
 			Handler: h.GetMessageStatus,
 		},
+		{
+			Name:    "juno_getBlockWithTxnHashesAndReceipts",
+			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
+			Handler: h.BlockWithTxHashesAndReceipts,
+		},
 	}, "/v0_8"
 }
 

rpc/subscriptions.go

@@ -686,7 +686,7 @@ func (h *Handler) sendHeader(w jsonrpc.Conn, header *core.Header, id uint64) err
 		Method:  "starknet_subscriptionNewHeads",
 		Params: map[string]any{
 			"subscription_id": id,
-			"result":          adaptBlockHeader(header),
+			"result":          AdaptBlockHeader(header),
 		},
 	})
 	if err != nil {