From 332504243ff715e5dca5a121981fce58d0da4ee4 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Wed, 18 Sep 2024 15:38:23 -0700 Subject: [PATCH] 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 | 2 +- Makefile | 16 +++++------ cmd/server/entrypoint.go | 7 +++-- cmd/server/main.go | 6 +++- server/server.go | 61 ++++++++++++++++++++-------------------- server/server_test.go | 4 +-- verify/cert.go | 7 ++--- verify/verifier.go | 6 ++-- 8 files changed, 56 insertions(+), 53 deletions(-) diff --git a/Dockerfile b/Dockerfile index 7b6f0e4..a618716 100644 --- a/Dockerfile +++ b/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 diff --git a/Makefile b/Makefile index 8dbd5b0..ca54a85 100644 --- a/Makefile +++ b/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 diff --git a/cmd/server/entrypoint.go b/cmd/server/entrypoint.go index 254740d..3f6eac2 100644 --- a/cmd/server/entrypoint.go +++ b/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) diff --git a/cmd/server/main.go b/cmd/server/main.go index 94de2f0..910a611 100644 --- a/cmd/server/main.go +++ b/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() diff --git a/server/server.go b/server/server.go index f6b1f05..50886cd 100644 --- a/server/server.go +++ b/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) } diff --git a/server/server_test.go b/server/server_test.go index 9fd4462..b8b872a 100644 --- a/server/server_test.go +++ b/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", diff --git a/verify/cert.go b/verify/cert.go index 163fcd8..b4214b7 100644 --- a/verify/cert.go +++ b/verify/cert.go @@ -55,13 +55,13 @@ 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 @@ -69,9 +69,8 @@ func (cv *CertVerifier) VerifyBatch( // 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[:]) diff --git a/verify/verifier.go b/verify/verifier.go index e19e302..828754b 100644 --- a/verify/verifier.go +++ b/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