feat: use collect mcycle root hashes API

Author: mpolitzer

pkg/emulator/machine.go

@@ -354,7 +354,7 @@ func (m *Machine) Run(mcycleEnd uint64) (BreakReason, error) {
 }
 
 // collect_mcycle_root_hashes
-func (m *Machine) CollectMCycleRootHashes(mcycleEnd, mcyclePeriod, mcyclePhase uint64, log2BundleMcycleCount int32, previousBackTree string) ([]byte, error) {
+func (m *Machine) CollectMCycleRootHashes(mcycleEnd, log2McyclePeriod, mcyclePhase uint64, log2BundleMcycleCount int32, previousBackTree string) ([]byte, error) {
 	var err error
 	var result []byte
 
@@ -368,7 +368,7 @@ func (m *Machine) CollectMCycleRootHashes(mcycleEnd, mcyclePeriod, mcyclePhase u
 		err = newError(C.cm_collect_mcycle_root_hashes(
 			m.ptr,
 			C.uint64_t(mcycleEnd),
-			C.uint64_t(mcyclePeriod),
+			C.uint64_t(log2McyclePeriod),
 			C.uint64_t(mcyclePhase),
 			C.int32_t(log2BundleMcycleCount),
 			previousBackTreeC,
@@ -425,10 +425,10 @@ func (m *Machine) SendCmioResponse(revertRootHash *Hash, reason uint16, data []b
 		}
 		err = newError(C.cm_send_cmio_response(
 			m.ptr,
-			ptrHash,
 			C.uint16_t(reason),
 			ptrData,
 			sizeData,
+			ptrHash,
 		))
 	})
 

pkg/machine/libcartesi.go

@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/bits"
 	"time"
 
 	"github.com/cartesi/rollups-node/pkg/emulator"
@@ -28,6 +29,7 @@ type RemoteMachineInterface interface {
 	Delete()
 	ForkServer() (*emulator.RemoteMachine, string, uint32, error)
 	ShutdownServer() error
+	CollectMCycleRootHashes(mcycleEnd, log2McyclePeriod, mcyclePhase uint64, log2BundleMcycleCount int32, previousBackTree string) ([]byte, error)
 }
 
 type proofJson struct {
@@ -230,124 +232,69 @@ func (e *LibCartesiBackend) CmioRxBufferSize() uint64 {
 	return 1 << emulator.CmioRxBufferLog2Size
 }
 
+func decodeBreakReason(s string) BreakReason {
+	switch s {
+	case "yielded_automatically":
+		return YieldedAutomatically
+	case "yielded_manually":
+		return YieldedManually
+	case "yielded_softly":
+		return YieldedSoftly
+	case "reached_target_mcycle":
+		return ReachedTargetMcycle
+	case "halted":
+		return Halted
+	case "failed":
+		return Failed
+	default:
+		return Failed
+	}
+}
+
 func (e *LibCartesiBackend) RunAndCollectRootHashes(
 	mcycleEnd uint64,
 	state *HashCollectorState,
 	timeout time.Duration,
 ) (reason BreakReason, err error) {
+
 	if state == nil {
 		return Failed, errors.New("nil state")
 	}
 	if state.Period == 0 {
 		return Failed, errors.New("State.Period must be > 0")
 	}
-
-	// Set up timeout management: calculate absolute deadline if timeout is specified
-	var deadline time.Time
-	hasDeadline := timeout > 0
-	if hasDeadline {
-		deadline = time.Now().Add(timeout)
-	}
-	remaining := func() time.Duration {
-		if !hasDeadline {
-			return 0
-		}
-		d := time.Until(deadline)
-		if d <= 0 {
-			return time.Nanosecond
-		}
-		return d
+	log2Period := uint64(bits.Len64(state.Period) - 1)
+	if (uint64(1) << log2Period != state.Period) {
+		return Failed, fmt.Errorf("period must be a power of 2, got %v.", state.Period)
 	}
-	checkDeadline := func() error {
-		if hasDeadline && time.Now().After(deadline) {
-			return errors.New("runWithRootHashes: deadline exceeded")
-		}
-		return nil
+	if err := e.inner.SetTimeout(timeout.Milliseconds()); err != nil {
+		return Failed, fmt.Errorf("failed to set operation timeout: %w", err)
 	}
 
-	if err := checkDeadline(); err != nil {
+	rawResult, err := e.inner.CollectMCycleRootHashes(mcycleEnd, log2Period, state.Phase, state.BundleLog2, "")
+	if err != nil {
 		return Failed, err
 	}
-	cur, err := e.ReadMCycle(remaining())
+	result := struct {
+		RootHashes  []string        `json:"hashes"`
+		MCyclePhase uint64          `json:"mcycle_phase"`
+		BreakReason string          `json:"break_reason"`
+		BackTree    json.RawMessage `json:"back_tree,omitempty"`
+	}{}
+	err = json.Unmarshal(rawResult, &result)
 	if err != nil {
-		return Failed, err
+		return Failed, fmt.Errorf("failed to unmarshal CollectMCycleRootHashes result: %w", err)
 	}
 
-	collected := (uint64)(0)
-
-	for {
-		if err := checkDeadline(); err != nil {
-			return Failed, err
-		}
-		if cur >= mcycleEnd {
-			// No more cycles to execute
-			return ReachedTargetMcycle, nil
-		}
-
-		// Calculate the next collection point: distance to the next multiple of the period
-		// This ensures we collect hashes at regular intervals aligned with the period
-		var step uint64
-		if r := state.Phase % state.Period; r == 0 {
-			step = state.Period
-		} else {
-			step = state.Period - r
-		}
-
-		nextHashCycle := cur + step
-		target := min(nextHashCycle, mcycleEnd)
-
-		// Run the machine until target cycle or until it yields/halts
-		br, err := e.Run(target, remaining())
-		if err != nil {
-			return Failed, err
-		}
-
-		// Check where we stopped after the run
-		if err := checkDeadline(); err != nil {
-			return Failed, err
-		}
-		pos, err := e.ReadMCycle(remaining())
-		if err != nil {
-			return Failed, err
-		}
-
-		advanced := pos - cur
-		state.Phase = (state.Phase + advanced) % state.Period
-		cur = pos
-
-		// Only collect hash if we reached the exact boundary (pos == nextHashCycle)
-		// This ensures "hash after each complete period", matching the C API behavior
-		// and avoiding duplicate collections if the machine stops early due to yields
-		if pos == nextHashCycle {
-			if err := checkDeadline(); err != nil {
-				return Failed, err
-			}
-			h, err := e.GetRootHash(remaining())
-			if err != nil {
-				return Failed, err
-			}
-
-			state.Hashes = append(state.Hashes, h)
-
-			collected++
-			if state.MaxHashes > 0 && collected >= state.MaxHashes {
-				return YieldedSoftly, nil
-			}
-		}
-
-		switch br {
-		case ReachedTargetMcycle:
-			if cur >= mcycleEnd {
-				return ReachedTargetMcycle, nil
-			}
-		case YieldedManually:
-			return br, nil
-		case YieldedAutomatically, YieldedSoftly, Halted:
-			return br, nil
-		case Failed:
-			return Failed, errors.New("run failed")
-		default:
-			return Failed, errors.New("unknown break reason")
+	// convert from base64 and append to collector state
+	for i, base64Hash := range result.RootHashes {
+		hash := Hash{}
+		if err := decodeB64To32(&hash, base64Hash); err != nil {
+			return Failed, fmt.Errorf("received an invalid hash during RunAndCollectRootHashes at index %v, with value: %v.", i, base64Hash)
 		}
+		state.Hashes = append(state.Hashes, hash)
 	}
+	state.Phase = result.MCyclePhase
+	state.BackTree = result.BackTree
+	return decodeBreakReason(result.BreakReason), nil
 }

pkg/machine/libcartesi_test.go

@@ -486,3 +486,8 @@ func (m *MockRemoteMachine) ShutdownServer() error {
 	args := m.Called()
 	return args.Error(0)
 }
+
+func (m *MockRemoteMachine) CollectMCycleRootHashes(mcycleEnd, log2McyclePeriod, mcyclePhase uint64, log2BundleMcycleCount int32, previousBackTree string) ([]byte, error) {
+	args := m.Called(mcycleEnd, log2McyclePeriod, mcyclePhase, log2BundleMcycleCount, previousBackTree)
+	return args.Get(0).([]byte), args.Error(1)
+}