First pass API for introspection of edges and assertions

api/BUILD.bazel

@@ -0,0 +1,43 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "api",
+    srcs = [
+        "data.go",
+        "edges.go",
+        "log.go",
+        "method_assertions.go",
+        "method_edges.go",
+        "method_healthz.go",
+        "server.go",
+    ],
+    importpath = "github.com/OffchainLabs/challenge-protocol-v2/api",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//chain-abstraction:protocol",
+        "@com_github_ethereum_go_ethereum//common",
+        "@com_github_ethereum_go_ethereum//log",
+        "@com_github_gorilla_mux//:mux",
+        "@org_golang_x_sync//errgroup",
+    ],
+)
+
+go_test(
+    name = "api_test",
+    srcs = [
+        "data_test.go",
+        "edges_test.go",
+        "method_assertions_test.go",
+        "method_edges_test.go",
+        "method_healthz_test.go",
+        "server_helper_test.go",
+        "server_test.go",
+    ],
+    embed = [":api"],
+    deps = [
+        "//chain-abstraction:protocol",
+        "//challenge-manager/challenge-tree/mock",
+        "@com_github_gorilla_mux//:mux",
+        "@in_gopkg_d4l3k_messagediff_v1//:messagediff_v1",
+    ],
+)

api/data.go

@@ -0,0 +1,9 @@
+package api
+
+import (
+	protocol "github.com/OffchainLabs/challenge-protocol-v2/chain-abstraction"
+)
+
+type DataAccessor interface {
+	GetEdges() []protocol.SpecEdge
+}

api/data_test.go

@@ -0,0 +1,16 @@
+package api_test
+
+import (
+	"github.com/OffchainLabs/challenge-protocol-v2/api"
+	protocol "github.com/OffchainLabs/challenge-protocol-v2/chain-abstraction"
+)
+
+var _ = api.DataAccessor(&FakeDataAccessor{})
+
+type FakeDataAccessor struct {
+	Edges []protocol.SpecEdge
+}
+
+func (f *FakeDataAccessor) GetEdges() []protocol.SpecEdge {
+	return f.Edges
+}

api/edges.go

@@ -0,0 +1,186 @@
+package api
+
+import (
+	"context"
+	"fmt"
+
+	protocol "github.com/OffchainLabs/challenge-protocol-v2/chain-abstraction"
+	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/sync/errgroup"
+)
+
+type Edge struct {
+	ID                  common.Hash            `json:"id"`
+	Type                string                 `json:"type"`
+	StartCommitment     *Commitment            `json:"startCommitment"`
+	EndCommitment       *Commitment            `json:"endCommitment"`
+	CreatedAtBlock      uint64                 `json:"createdAtBlock"`
+	MutualID            common.Hash            `json:"mutualId"`
+	OriginID            common.Hash            `json:"originId"`
+	ClaimID             common.Hash            `json:"claimId"`
+	HasChildren         bool                   `json:"hasChildren"`
+	LowerChildID        common.Hash            `json:"lowerChildId"`
+	UpperChildID        common.Hash            `json:"upperChildId"`
+	MiniStaker          common.Address         `json:"miniStaker"`
+	AssertionHash       common.Hash            `json:"assertionHash"`
+	TimeUnrivaled       uint64                 `json:"timeUnrivaled"`
+	HasRival            bool                   `json:"hasRival"`
+	Status              string                 `json:"status"`
+	HasLengthOneRival   bool                   `json:"hasLengthOneRival"`
+	TopLevelClaimHeight protocol.OriginHeights `json:"topLevelClaimHeight"`
+
+	// Validator's point of view
+	// IsHonest bool `json:"isHonest"`
+	// AgreesWithStartCommitment `json:"agreesWithStartCommitment"`
+}
+
+type Commitment struct {
+	Height uint64      `json:"height"`
+	Hash   common.Hash `json:"hash"`
+}
+
+func convertSpecEdgeEdgesToEdges(ctx context.Context, e []protocol.SpecEdge) ([]*Edge, error) {
+	// Convert concurrently as some of the underlying methods are API calls.
+	eg, ctx := errgroup.WithContext(ctx)
+
+	edges := make([]*Edge, len(e))
+	for i, edge := range e {
+		index := i
+		ee := edge
+
+		eg.Go(func() (err error) {
+			edges[index], err = convertSpecEdgeEdgeToEdge(ctx, ee)
+			return
+		})
+	}
+	return edges, eg.Wait()
+}
+
+func convertSpecEdgeEdgeToEdge(ctx context.Context, e protocol.SpecEdge) (*Edge, error) {
+	edge := &Edge{
+		ID:              common.Hash(e.Id()),
+		Type:            e.GetType().String(),
+		StartCommitment: toCommitment(e.StartCommitment),
+		EndCommitment:   toCommitment(e.EndCommitment),
+		MutualID:        common.Hash(e.MutualId()),
+		OriginID:        common.Hash(e.OriginId()),
+		ClaimID: func() common.Hash {
+			if !e.ClaimId().IsNone() {
+				return common.Hash(e.ClaimId().Unwrap())
+			}
+			return common.Hash{}
+		}(),
+		MiniStaker: func() common.Address {
+			if !e.MiniStaker().IsNone() {
+				return common.Address(e.MiniStaker().Unwrap())
+			}
+			return common.Address{}
+		}(),
+		CreatedAtBlock: func() uint64 {
+			cab, err := e.CreatedAtBlock()
+			if err != nil {
+				return 0
+			}
+			return cab
+		}(),
+	}
+
+	// The following methods include calls to the backend, so we run them concurrently.
+	// Note: No rate limiting currently in place.
+	eg, ctx := errgroup.WithContext(ctx)
+
+	eg.Go(func() error {
+		hasChildren, err := e.HasChildren(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge children: %w", err)
+		}
+		edge.HasChildren = hasChildren
+		return nil
+	})
+
+	eg.Go(func() error {
+		lowerChild, err := e.LowerChild(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge lower child: %w", err)
+		}
+		if !lowerChild.IsNone() {
+			edge.LowerChildID = common.Hash(lowerChild.Unwrap())
+		}
+		return nil
+	})
+
+	eg.Go(func() error {
+		upperChild, err := e.UpperChild(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge upper child: %w", err)
+		}
+		if !upperChild.IsNone() {
+			edge.UpperChildID = common.Hash(upperChild.Unwrap())
+		}
+		return nil
+	})
+
+	eg.Go(func() error {
+		ah, err := e.AssertionHash(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge assertion hash: %w", err)
+		}
+		edge.AssertionHash = common.Hash(ah)
+		return nil
+	})
+
+	eg.Go(func() error {
+		timeUnrivaled, err := e.TimeUnrivaled(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge time unrivaled: %w", err)
+		}
+		edge.TimeUnrivaled = timeUnrivaled
+		return nil
+	})
+
+	eg.Go(func() error {
+		hasRival, err := e.HasRival(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge has rival: %w", err)
+		}
+		edge.HasRival = hasRival
+		return nil
+	})
+
+	eg.Go(func() error {
+		status, err := e.Status(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge status: %w", err)
+		}
+		edge.Status = status.String()
+		return nil
+	})
+
+	eg.Go(func() error {
+		hasLengthOneRival, err := e.HasLengthOneRival(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge has length one rival: %w", err)
+		}
+		edge.HasLengthOneRival = hasLengthOneRival
+		return nil
+	})
+
+	eg.Go(func() error {
+		topLevelClaimHeight, err := e.TopLevelClaimHeight(ctx)
+		if err != nil {
+			return fmt.Errorf("failed to get edge top level claim height: %w", err)
+		}
+		edge.TopLevelClaimHeight = topLevelClaimHeight
+		return nil
+	})
+
+	return edge, eg.Wait()
+}
+
+func toCommitment(fn func() (protocol.Height, common.Hash)) *Commitment {
+	h, hs := fn()
+	return &Commitment{
+		Height: uint64(h),
+		Hash:   hs,
+	}
+}

api/edges_test.go

@@ -0,0 +1,37 @@
+package api_test
+
+import (
+	"github.com/OffchainLabs/challenge-protocol-v2/api"
+	protocol "github.com/OffchainLabs/challenge-protocol-v2/chain-abstraction"
+	"github.com/OffchainLabs/challenge-protocol-v2/challenge-manager/challenge-tree/mock"
+)
+
+func edgesToMockEdges(e []*api.Edge) []*mock.Edge {
+	me := make([]*mock.Edge, len(e))
+	for i, ee := range e {
+		me[i] = edgeToMockEdge(ee)
+	}
+	return me
+}
+
+func edgeToMockEdge(e *api.Edge) *mock.Edge {
+	return &mock.Edge{
+		ID: mock.EdgeId(e.ID.Bytes()),
+		EdgeType: func() protocol.EdgeType {
+			et, err := protocol.EdgeTypeFromString(e.Type)
+			if err != nil {
+				panic(err)
+			}
+			return et
+		}(),
+		StartHeight:   e.StartCommitment.Height,
+		StartCommit:   mock.Commit(e.StartCommitment.Hash.Bytes()),
+		EndHeight:     e.EndCommitment.Height,
+		EndCommit:     mock.Commit(e.EndCommitment.Hash.Bytes()),
+		OriginID:      mock.OriginId(e.OriginID.Bytes()),
+		ClaimID:       string(e.ClaimID.Bytes()),
+		LowerChildID:  mock.EdgeId(e.LowerChildID.Bytes()),
+		UpperChildID:  mock.EdgeId(e.UpperChildID.Bytes()),
+		CreationBlock: e.CreatedAtBlock,
+	}
+}

api/log.go

@@ -0,0 +1,7 @@
+package api
+
+import gethLog "github.com/ethereum/go-ethereum/log"
+
+var (
+	log = gethLog.New("service", "api")
+)

api/method_assertions.go

@@ -0,0 +1,17 @@
+package api
+
+import "net/http"
+
+func listAssertionsHandler(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusNotImplemented)
+	if _, err := w.Write([]byte("not implemented")); err != nil {
+		log.Error("failed to write response body", "err", err)
+	}
+}
+
+func getAssertionHandler(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusNotImplemented)
+	if _, err := w.Write([]byte("not implemented")); err != nil {
+		log.Error("failed to write response body", "err", err)
+	}
+}

api/method_assertions_test.go

@@ -0,0 +1,49 @@
+package api_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestListAssertions(t *testing.T) {
+	s, _ := NewTestServer(t)
+
+	req, err := http.NewRequest("GET", "/assertions", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.
+	rr := httptest.NewRecorder()
+
+	// Serve the request with the http recorder.
+	s.Router().ServeHTTP(rr, req)
+
+	// Check the status code is what we expect.
+	if status := rr.Code; status != http.StatusNotImplemented {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusNotImplemented)
+	}
+}
+
+func TestGetAssertion(t *testing.T) {
+	s, _ := NewTestServer(t)
+
+	req, err := http.NewRequest("GET", "/assertions/foo", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.
+	rr := httptest.NewRecorder()
+
+	// Serve the request with the http recorder.
+	s.Router().ServeHTTP(rr, req)
+
+	// Check the status code is what we expect.
+	if status := rr.Code; status != http.StatusNotImplemented {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusNotImplemented)
+	}
+}