chore: bunch of small refactors for improved devex (#124)

* fix: Dockerfile syntax warning (as -> AS)

* fix: injected ldflags

* chore: tag make build-docker image with :dev

* chore: better error logging

* fix: lint

* refactor: single var block declaration

* fix: server_tests

Dockerfile

@@ -1,6 +1,6 @@
 # multi container builds ftw
 
-FROM golang:1.21.10-alpine3.19 as builder
+FROM golang:1.21.10-alpine3.19 AS builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers jq bash git
 

Makefile

@@ -1,15 +1,14 @@
-IMAGE_NAME = ghcr.io/layr-labs/eigenda-proxy
 LINTER_VERSION = v1.52.1
 LINTER_URL = https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh
 GET_LINT_CMD = "curl -sSfL $(LINTER_URL) | sh -s -- -b $(go env GOPATH)/bin $(LINTER_VERSION)"
 
-GITCOMMIT ?= $(shell git rev-parse HEAD)
-GITDATE ?= $(shell git show -s --format='%ct')
-VERSION := v0.0.0
+GIT_COMMIT ?= $(shell git rev-parse HEAD)
+BUILD_TIME := $(shell date -u '+%Y-%m-%d--%H:%M:%S')
+GIT_TAG := $(shell git describe --tags --always --dirty)
 
-LDFLAGSSTRING +=-X main.GitCommit=$(GITCOMMIT)
-LDFLAGSSTRING +=-X main.GitDate=$(GITDATE)
-LDFLAGSSTRING +=-X main.Version=$(VERSION)
+LDFLAGSSTRING +=-X main.Commit=$(GIT_COMMIT)
+LDFLAGSSTRING +=-X main.Date=$(BUILD_TIME)
+LDFLAGSSTRING +=-X main.Version=$(GIT_TAG)
 LDFLAGS := -ldflags "$(LDFLAGSSTRING)"
 
 E2ETEST = INTEGRATION=true go test -timeout 1m -v ./e2e -parallel 4 -deploy-config ../.devnet/devnetL1.json
@@ -21,7 +20,8 @@ eigenda-proxy:
 
 .PHONY: docker-build
 docker-build:
-	@docker build -t $(IMAGE_NAME) .
+	# we only use this to build the docker image locally, so we give it the dev tag as a reminder
+	@docker build -t ghcr.io/layr-labs/eigenda-proxy:dev .
 
 run-minio:
 	docker run -p 4566:9000 -d -e "MINIO_ROOT_USER=minioadmin" -e "MINIO_ROOT_PASSWORD=minioadmin" --name minio minio/minio server /data

cmd/server/entrypoint.go

@@ -13,6 +13,10 @@ import (
 )
 
 func StartProxySvr(cliCtx *cli.Context) error {
+	log := oplog.NewLogger(oplog.AppOut(cliCtx), oplog.ReadCLIConfig(cliCtx)).New("role", "eigenda_proxy")
+	oplog.SetGlobalLogHandler(log.Handler())
+	log.Info("Starting EigenDA Proxy Server", "version", Version, "date", Date, "commit", Commit)
+
 	cfg := server.ReadCLIConfig(cliCtx)
 	if err := cfg.Check(); err != nil {
 		return err
@@ -22,9 +26,6 @@ func StartProxySvr(cliCtx *cli.Context) error {
 
 	m := metrics.NewMetrics("default")
 
-	log := oplog.NewLogger(oplog.AppOut(cliCtx), oplog.ReadCLIConfig(cliCtx)).New("role", "eigenda_proxy")
-	oplog.SetGlobalLogHandler(log.Handler())
-
 	log.Info("Initializing EigenDA proxy server...")
 
 	daRouter, err := server.LoadStoreRouter(ctx, cfg, log)

cmd/server/main.go

@@ -16,7 +16,11 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/opio"
 )
 
-var Version = "v1.1.0"
+var (
+	Version = "unknown"
+	Commit  = "unknown"
+	Date    = "unknown"
+)
 
 func main() {
 	oplog.SetupDefaults()

server/server.go

@@ -25,14 +25,10 @@ var (
 )
 
 const (
-	invalidDomain         = "invalid domain type"
-	invalidCommitmentMode = "invalid commitment mode"
-
 	GetRoute = "/get/"
 	PutRoute = "/put/"
 	Put      = "put"
 
-	DomainFilterKey   = "domain"
 	CommitmentModeKey = "commitment_mode"
 )
 
@@ -153,26 +149,27 @@ func (svr *Server) Health(w http.ResponseWriter, _ *http.Request) error {
 func (svr *Server) HandleGet(w http.ResponseWriter, r *http.Request) (commitments.CommitmentMeta, error) {
 	meta, err := ReadCommitmentMeta(r)
 	if err != nil {
-		svr.WriteBadRequest(w, invalidCommitmentMode)
-		return meta, err
+		err = fmt.Errorf("invalid commitment mode: %w", err)
+		svr.WriteBadRequest(w, err)
+		return commitments.CommitmentMeta{}, err
 	}
 	key := path.Base(r.URL.Path)
 	comm, err := commitments.StringToDecodedCommitment(key, meta.Mode)
 	if err != nil {
-		svr.log.Info("failed to decode commitment", "err", err, "commitment", comm)
-		w.WriteHeader(http.StatusBadRequest)
-		return meta, err
+		err = fmt.Errorf("failed to decode commitment from key %v (commitment mode %v): %w", key, meta.Mode, err)
+		svr.WriteBadRequest(w, err)
+		return commitments.CommitmentMeta{}, err
 	}
 
 	input, err := svr.router.Get(r.Context(), comm, meta.Mode)
-	if err != nil && errors.Is(err, ErrNotFound) {
-		svr.WriteNotFound(w, err.Error())
-		return meta, err
-	}
-
 	if err != nil {
-		svr.WriteInternalError(w, err)
-		return meta, err
+		err = fmt.Errorf("get request failed with commitment %v (commitment mode %v): %w", comm, meta.Mode, err)
+		if errors.Is(err, ErrNotFound) {
+			svr.WriteNotFound(w, err)
+		} else {
+			svr.WriteInternalError(w, err)
+		}
+		return commitments.CommitmentMeta{}, err
 	}
 
 	svr.WriteResponse(w, input)
@@ -182,15 +179,16 @@ func (svr *Server) HandleGet(w http.ResponseWriter, r *http.Request) (commitment
 func (svr *Server) HandlePut(w http.ResponseWriter, r *http.Request) (commitments.CommitmentMeta, error) {
 	meta, err := ReadCommitmentMeta(r)
 	if err != nil {
-		svr.WriteBadRequest(w, invalidCommitmentMode)
-		return meta, err
+		err = fmt.Errorf("invalid commitment mode: %w", err)
+		svr.WriteBadRequest(w, err)
+		return commitments.CommitmentMeta{}, err
 	}
 
 	input, err := io.ReadAll(r.Body)
 	if err != nil {
-		svr.log.Error("Failed to read request body", "err", err)
-		w.WriteHeader(http.StatusBadRequest)
-		return meta, err
+		err = fmt.Errorf("failed to read request body: %w", err)
+		svr.WriteBadRequest(w, err)
+		return commitments.CommitmentMeta{}, err
 	}
 
 	key := path.Base(r.URL.Path)
@@ -199,23 +197,24 @@ func (svr *Server) HandlePut(w http.ResponseWriter, r *http.Request) (commitment
 	if len(key) > 0 && key != Put { // commitment key already provided (keccak256)
 		comm, err = commitments.StringToDecodedCommitment(key, meta.Mode)
 		if err != nil {
-			svr.log.Info("failed to decode commitment", "err", err, "key", key)
-			w.WriteHeader(http.StatusBadRequest)
-			return meta, err
+			err = fmt.Errorf("failed to decode commitment from key %v (commitment mode %v): %w", key, meta.Mode, err)
+			svr.WriteBadRequest(w, err)
+			return commitments.CommitmentMeta{}, err
 		}
 	}
 
 	commitment, err := svr.router.Put(r.Context(), meta.Mode, comm, input)
 	if err != nil {
+		err = fmt.Errorf("put request failed with commitment %v (commitment mode %v): %w", comm, meta.Mode, err)
 		svr.WriteInternalError(w, err)
 		return meta, err
 	}
 
 	responseCommit, err := commitments.EncodeCommitment(commitment, meta.Mode)
 	if err != nil {
-		svr.log.Info("failed to encode commitment", "err", err)
-		w.WriteHeader(http.StatusInternalServerError)
-		return meta, err
+		err = fmt.Errorf("failed to encode commitment %v (commitment mode %v): %w", commitment, meta.Mode, err)
+		svr.WriteInternalError(w, err)
+		return commitments.CommitmentMeta{}, err
 	}
 
 	svr.log.Info(fmt.Sprintf("write commitment: %x\n", comm))
@@ -235,13 +234,13 @@ func (svr *Server) WriteInternalError(w http.ResponseWriter, err error) {
 	w.WriteHeader(http.StatusInternalServerError)
 }
 
-func (svr *Server) WriteNotFound(w http.ResponseWriter, msg string) {
-	svr.log.Info("not found", "msg", msg)
+func (svr *Server) WriteNotFound(w http.ResponseWriter, err error) {
+	svr.log.Info("not found", "err", err)
 	w.WriteHeader(http.StatusNotFound)
 }
 
-func (svr *Server) WriteBadRequest(w http.ResponseWriter, msg string) {
-	svr.log.Info("bad request", "msg", msg)
+func (svr *Server) WriteBadRequest(w http.ResponseWriter, err error) {
+	svr.log.Info("bad request", "err", err)
 	w.WriteHeader(http.StatusBadRequest)
 }
 

server/server_test.go

@@ -84,7 +84,7 @@ func TestGetHandler(t *testing.T) {
 			expectedCode:           http.StatusInternalServerError,
 			expectedBody:           "",
 			expectError:            true,
-			expectedCommitmentMeta: commitments.CommitmentMeta{Mode: commitments.OptimismGeneric, CertVersion: 0},
+			expectedCommitmentMeta: commitments.CommitmentMeta{},
 		},
 		{
 			name: "Success - OP Keccak256",
@@ -106,7 +106,7 @@ func TestGetHandler(t *testing.T) {
 			expectedCode:           http.StatusInternalServerError,
 			expectedBody:           "",
 			expectError:            true,
-			expectedCommitmentMeta: commitments.CommitmentMeta{Mode: commitments.OptimismAltDA, CertVersion: 0},
+			expectedCommitmentMeta: commitments.CommitmentMeta{},
 		},
 		{
 			name: "Success - OP Alt-DA",

verify/cert.go

@@ -55,23 +55,22 @@ func (cv *CertVerifier) VerifyBatch(
 ) error {
 	blockNumber, err := cv.getConfDeepBlockNumber()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get context block: %w", err)
 	}
 
 	// 1. ensure that a batch hash can be looked up for a batch ID for a given block number
 	expectedHash, err := cv.manager.BatchIdToBatchMetadataHash(&bind.CallOpts{BlockNumber: blockNumber}, id)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get batch metadata hash: %w", err)
 	}
 	if bytes.Equal(expectedHash[:], make([]byte, 32)) {
 		return ErrBatchMetadataHashNotFound
 	}
 
 	// 2. ensure that hash generated from local cert matches one stored on-chain
 	actualHash, err := HashBatchMetadata(header, recordHash, confirmationNumber)
-
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to hash batch metadata: %w", err)
 	}
 
 	equal := slices.Equal(expectedHash[:], actualHash[:])

verify/verifier.go

@@ -69,19 +69,19 @@ func (v *Verifier) VerifyCert(cert *Certificate) error {
 
 	err := v.cv.VerifyBatch(&header, cert.Proof().GetBatchId(), [32]byte(cert.Proof().BatchMetadata.GetSignatoryRecordHash()), cert.Proof().BatchMetadata.GetConfirmationBlockNumber())
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to verify batch: %w", err)
 	}
 
 	// 2 - verify merkle inclusion proof
 	err = v.cv.VerifyMerkleProof(cert.Proof().GetInclusionProof(), cert.BatchHeaderRoot(), cert.Proof().GetBlobIndex(), cert.ReadBlobHeader())
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to verify merkle proof: %w", err)
 	}
 
 	// 3 - verify security parameters
 	err = v.VerifySecurityParams(cert.ReadBlobHeader(), header)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to verify security parameters: %w", err)
 	}
 
 	return nil