fetcher_api.go

package dasmon

import (
	"context"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
)

var _ Fetcher = &FetcherBeaconAPI{}

type FetcherBeaconAPI struct {
	baseURL string
	client  *http.Client
}

func NewFetcherBeaconAPI(baseURL string) *FetcherBeaconAPI {
	return &FetcherBeaconAPI{
		baseURL: baseURL,
		client: &http.Client{
			Timeout: 10 * time.Second,
		},
	}
}

func (f *FetcherBeaconAPI) MaxSlotsPerFetch() uint64 {
	return 1
}

func (f *FetcherBeaconAPI) FetchCommitments(ctx context.Context, fetchRange Range[uint64]) ([]*BlockCommitmentInfo, error) {
	if fetchRange.End-fetchRange.Start != 0 {
		return nil, fmt.Errorf("beacon API fetcher only supports single slot fetches")
	}

	slot := fetchRange.Start

	url := fmt.Sprintf("%s/eth/v2/beacon/blocks/%d", f.baseURL, slot)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Accept", "application/json")

	resp, err := f.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch block from API: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("failed to fetch block at slot %d: %s", slot, body)
	}

	// Parse JSON response
	var apiResp struct {
		Data struct {
			Message struct {
				Slot string `json:"slot"`
				Body struct {
					BlobKZGCommitments []string `json:"blob_kzg_commitments"`
				} `json:"body"`
			} `json:"message"`
		} `json:"data"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
		return nil, fmt.Errorf("failed to decode API response: %w", err)
	}

	// Convert hex-encoded commitments to byte slices
	commitments := make([][]byte, len(apiResp.Data.Message.Body.BlobKZGCommitments))
	for i, comm := range apiResp.Data.Message.Body.BlobKZGCommitments {
		comm, err := hex.DecodeString(strings.TrimPrefix(comm, "0x"))
		if err != nil {
			return nil, fmt.Errorf("failed to decode commitment hex string: %w", err)
		}
		commitments[i] = comm
	}

	// TODO
	// For now, we don't have the block root from this API response
	// In a real implementation, you might need to compute it or fetch it separately
	// For our purposes, we'll leave it as zero and rely on slot-based lookups
	var blockRoot [32]byte

	comm := &BlockCommitmentInfo{
		Slot:            fetchRange.Start,
		BlockRoot:       blockRoot,
		BlobCommitments: commitments,
	}

	return []*BlockCommitmentInfo{comm}, nil
}

func (f *FetcherBeaconAPI) Close() error {
	f.client.CloseIdleConnections()
	return nil
}