add PUT /api/v1/tree/pin endpoint

api/api.go

@@ -32,6 +32,7 @@ func New(db *pgxpool.Pool) *Server {
 func (s *Server) Handler(env, gitSha string) http.Handler {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/api/v1/tree", s.TreeHandler)
+	mux.HandleFunc("/api/v1/tree/pin", s.PinTree)
 	mux.HandleFunc("/api/v1/proof", s.GetProof)
 	mux.HandleFunc("/api/v1/root", s.GetRoot)
 	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {

api/ipfs.go

@@ -0,0 +1,95 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/contextwtf/lanyard/api/tracing"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+var (
+	ipfsPinningServiceURL = os.Getenv("IPFS_PINNING_SERVICE_URL")
+	ipfsPinningSecret     = os.Getenv("IPFS_PINNING_SECRET")
+	hc                    = &http.Client{
+		Timeout: time.Second * 10,
+	}
+)
+
+func (s *Server) pinTree(ctx context.Context, root hexutil.Bytes) (string, error) {
+	if ipfsPinningServiceURL == "" {
+		return "", errors.New("IPFS_PINNING_SERVICE_URL not set")
+	}
+
+	const q = `
+		SELECT unhashed_leaves, ltd, packed
+		FROM trees
+		WHERE root = $1
+	`
+	tr := struct {
+		Root           hexutil.Bytes   `json:"root"`
+		UnhashedLeaves []hexutil.Bytes `json:"unhashedLeaves"`
+		Ltd            []string        `json:"leafTypeDescriptor"`
+		Packed         jsonNullBool    `json:"packedEncoding"`
+	}{
+		Root: root,
+	}
+
+	err := s.db.QueryRow(ctx, q, root).Scan(
+		&tr.UnhashedLeaves,
+		&tr.Ltd,
+		&tr.Packed,
+	)
+
+	if err != nil {
+		return "", err
+	}
+
+	msg, err := json.Marshal(tr)
+
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequestWithContext(
+		ctx, "POST", ipfsPinningServiceURL, bytes.NewReader(msg),
+	)
+
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+ipfsPinningSecret)
+	req.Header.Set("Content-Type", "application/json")
+
+	span, ctx := tracing.SpanFromContext(ctx, "ipfs.pinTree")
+	res, err := hc.Do(req)
+	span.Finish()
+
+	if err != nil {
+		return "", err
+	}
+
+	if res.StatusCode >= 400 {
+		return "", errors.New(res.Status)
+	}
+
+	type resp struct {
+		Hash string `json:"IpfsHash"`
+	}
+
+	defer res.Body.Close()
+
+	var r resp
+	err = json.NewDecoder(res.Body).Decode(&r)
+	if err != nil {
+		return "", err
+	}
+
+	return r.Hash, nil
+}

api/tree.go

@@ -228,3 +228,38 @@ func (s *Server) GetTree(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Cache-Control", "public, max-age=3600")
 	s.sendJSON(r, w, tr)
 }
+
+func (s *Server) PinTree(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPut {
+		http.Error(w, "unsupported method", http.StatusMethodNotAllowed)
+		return
+	}
+
+	type pinTreeReq struct {
+		MerkleRoot hexutil.Bytes `json:"merkleRoot"`
+	}
+
+	var (
+		req pinTreeReq
+		ctx = r.Context()
+	)
+	defer r.Body.Close()
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		s.sendJSONError(r, w, err, http.StatusBadRequest, "unhashedLeaves must be a list of hex strings")
+		return
+	}
+
+	hash, err := s.pinTree(ctx, req.MerkleRoot)
+
+	if errors.Is(err, pgx.ErrNoRows) {
+		s.sendJSONError(r, w, err, http.StatusNotFound, "tree not found for root")
+		return
+	} else if err != nil {
+		s.sendJSONError(r, w, err, http.StatusInternalServerError, "selecting tree")
+		return
+	}
+
+	s.sendJSON(r, w, map[string]any{
+		"ipfsHash": "ipfs://" + hash,
+	})
+}