Revert "Nitro Integration Misc Details" (#402)

Author: rauljordan

assertions/BUILD.bazel

@@ -12,7 +12,6 @@ go_library(
         "//chain-abstraction:protocol",
         "//chain-abstraction/sol-implementation",
         "//challenge-manager/types",
-        "//containers",
         "//layer2-state-provider",
         "//runtime",
         "//solgen/go/rollupgen",

assertions/scanner.go

@@ -15,7 +15,6 @@ import (
 
 	protocol "github.com/OffchainLabs/bold/chain-abstraction"
 	"github.com/OffchainLabs/bold/challenge-manager/types"
-	"github.com/OffchainLabs/bold/containers"
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
 	retry "github.com/OffchainLabs/bold/runtime"
 	"github.com/OffchainLabs/bold/solgen/go/rollupgen"
@@ -170,57 +169,37 @@ func (s *Scanner) ProcessAssertionCreation(
 	ctx context.Context,
 	assertionHash protocol.AssertionHash,
 ) error {
+	srvlog.Info("Processed assertion creation event", log.Ctx{"validatorName": s.validatorName})
+	s.assertionsProcessedCount++
 	creationInfo, err := s.chain.ReadAssertionCreationInfo(ctx, assertionHash)
 	if err != nil {
-		srvlog.Error("Could not read creation", log.Ctx{"err": err})
 		return err
 	}
-	prevAssertionHash := creationInfo.ParentAssertionHash
-	// If the assertion is the genesis assertion, we ignore it.
-	if (prevAssertionHash == common.Hash{}) {
-		return nil
-	}
-	srvlog.Info("Processing assertion creation event", log.Ctx{"validatorName": s.validatorName, "hash": containers.Trunc(assertionHash.Hash[:])})
-	s.assertionsProcessedCount++
-
-	prevAssertion, err := s.chain.GetAssertion(ctx, protocol.AssertionHash{Hash: prevAssertionHash})
+	prevAssertion, err := s.chain.GetAssertion(ctx, protocol.AssertionHash{Hash: creationInfo.ParentAssertionHash})
 	if err != nil {
-		srvlog.Error("Could not get prev assertion", log.Ctx{"err": err})
 		return err
 	}
 	hasSecondChild, err := prevAssertion.HasSecondChild()
 	if err != nil {
-		srvlog.Error("Could not check if has second child", log.Ctx{"err": err})
 		return err
 	}
 	if !hasSecondChild {
 		srvlog.Info("No fork detected in assertion chain", log.Ctx{"validatorName": s.validatorName})
 		return nil
 	}
-	srvlog.Info("Assertion has second child", log.Ctx{"hash": containers.Trunc(prevAssertionHash[:])})
 	s.forksDetectedCount++
-
 	execState := protocol.GoExecutionStateFromSolidity(creationInfo.AfterState)
 	msgCount, err := s.stateProvider.ExecutionStateMsgCount(ctx, execState)
 	switch {
 	case errors.Is(err, l2stateprovider.ErrNoExecutionState):
-		srvlog.Warn("Disagreed with execution state of posted assertion", log.Ctx{
-			"parentAssertionHash":   containers.Trunc(creationInfo.ParentAssertionHash[:]),
-			"detectedAssertionHash": containers.Trunc(assertionHash.Hash[:]),
-			"msgCount":              msgCount,
-		})
 		return nil
 	case err != nil:
-		srvlog.Error("Could not check execution state msg count for seen assertion", log.Ctx{"err": err})
 		return err
 	default:
 	}
-	srvlog.Info("Agreed with execution state of posted assertion", log.Ctx{
-		"parentAssertionHash":   containers.Trunc(creationInfo.ParentAssertionHash[:]),
-		"detectedAssertionHash": containers.Trunc(assertionHash.Hash[:]),
-		"msgCount":              msgCount,
-	})
+
 	if s.challengeReader.Mode() == types.DefensiveMode || s.challengeReader.Mode() == types.MakeMode {
+
 		// Generating a random integer between 0 and max delay second to wait before challenging.
 		// This is to avoid all validators challenging at the same time.
 		mds := 1 // default max delay seconds to 1 to avoid panic
@@ -231,7 +210,6 @@ func (s *Scanner) ProcessAssertionCreation(
 		if err != nil {
 			return err
 		}
-		srvlog.Info("Submitting a challenge to assertion with two children", log.Ctx{"assertionHash": containers.Trunc(prevAssertionHash[:])})
 		srvlog.Info("Waiting before challenging", log.Ctx{"delay": randSecs})
 		time.Sleep(time.Duration(randSecs) * time.Second)
 
@@ -241,6 +219,12 @@ func (s *Scanner) ProcessAssertionCreation(
 		s.challengesSubmittedCount++
 		return nil
 	}
+
+	srvlog.Error("Detected invalid assertion, but not configured to challenge", log.Ctx{
+		"parentAssertionHash":   creationInfo.ParentAssertionHash,
+		"detectedAssertionHash": assertionHash,
+		"msgCount":              msgCount,
+	})
 	return nil
 }
 

assertions/scanner_test.go

@@ -22,16 +22,6 @@ import (
 
 func TestScanner_ProcessAssertionCreation(t *testing.T) {
 	ctx := context.Background()
-	t.Run("ignores genesis", func(t *testing.T) {
-		p := &mocks.MockProtocol{}
-		assertionHash := mockId(1)
-		p.On("ReadAssertionCreationInfo", ctx, assertionHash).Return(&protocol.AssertionCreatedInfo{
-			ParentAssertionHash: common.Hash{},
-		}, nil)
-		scanner := assertions.NewScanner(p, nil, nil, nil, common.Address{}, "", time.Second)
-		err := scanner.ProcessAssertionCreation(ctx, assertionHash)
-		require.NoError(t, err)
-	})
 	t.Run("no fork detected", func(t *testing.T) {
 		manager, _, mockStateProvider, cfg := setupChallengeManager(t)
 

chain-abstraction/interfaces.go

@@ -69,9 +69,7 @@ func (i AssertionCreatedInfo) ExecutionHash() common.Hash {
 type AssertionChain interface {
 	// Read-only methods.
 	GetAssertion(ctx context.Context, id AssertionHash) (Assertion, error)
-	GenesisAssertionHash(ctx context.Context) (common.Hash, error)
 	LatestConfirmed(ctx context.Context) (Assertion, error)
-	RollupAddress() common.Address
 	LatestCreatedAssertion(ctx context.Context) (Assertion, error)
 	ReadAssertionCreationInfo(
 		ctx context.Context, id AssertionHash,

chain-abstraction/sol-implementation/assertion_chain.go

@@ -101,10 +101,6 @@ func NewAssertionChain(
 	return chain, nil
 }
 
-func (a *AssertionChain) RollupAddress() common.Address {
-	return a.rollupAddr
-}
-
 func (a *AssertionChain) GetAssertion(ctx context.Context, assertionHash protocol.AssertionHash) (protocol.Assertion, error) {
 	var b [32]byte
 	copy(b[:], assertionHash.Bytes())

challenge-manager/edge-tracker/tracker.go

@@ -258,8 +258,7 @@ func (et *Tracker) Act(ctx context.Context) error {
 	// Edge tracker should add a subchallenge level zero leaf.
 	case edgeAddingSubchallengeLeaf:
 		if err := et.openSubchallengeLeaf(ctx); err != nil {
-			fields["err"] = err
-			srvlog.Error("Could not open subchallenge leaf", fields)
+			srvlog.Error("Could not open subchallenge leaf", err, fields)
 			return et.fsm.Do(edgeBackToStart{})
 		}
 		layerZeroLeafCounter.Inc(1)

contracts/src/mocks/SimpleOneStepProofEntry.sol

@@ -46,6 +46,6 @@ contract SimpleOneStepProofEntry is IOneStepProofEntry {
 
     function getMachineHash(ExecutionState calldata execState) external pure override returns (bytes32) {
         require(execState.machineStatus == MachineStatus.FINISHED, "BAD_MACHINE_STATUS");
-        return keccak256(abi.encodePacked("Machine finished:", execState.globalState.hash()));
+        return execState.globalState.hash();
     }
 }

testing/mocks/mocks.go

@@ -404,11 +404,6 @@ func (m *MockProtocol) NumAssertions(ctx context.Context) (uint64, error) {
 	return args.Get(0).(uint64), args.Error(1)
 }
 
-func (m *MockProtocol) RollupAddress() common.Address {
-	args := m.Called()
-	return args.Get(0).(common.Address)
-}
-
 func (m *MockProtocol) GetAssertion(ctx context.Context, id protocol.AssertionHash) (protocol.Assertion, error) {
 	args := m.Called(ctx, id)
 	return args.Get(0).(protocol.Assertion), args.Error(1)
@@ -424,11 +419,6 @@ func (m *MockProtocol) TopLevelAssertion(ctx context.Context, edgeId protocol.Ed
 	return args.Get(0).(protocol.AssertionHash), args.Error(1)
 }
 
-func (m *MockProtocol) GenesisAssertionHash(ctx context.Context) (common.Hash, error) {
-	args := m.Called(ctx)
-	return args.Get(0).(common.Hash), args.Error(1)
-}
-
 func (m *MockProtocol) TopLevelClaimHeights(ctx context.Context, edgeId protocol.EdgeId) (protocol.OriginHeights, error) {
 	args := m.Called(ctx, edgeId)
 	return args.Get(0).(protocol.OriginHeights), args.Error(1)