feat(evmreader): fast sync application inputs and outputs

This is an optimization to decrease the number of blocks the node has to
scan for an new application. By retrieving zero from GetNumberOfInputs
call, we can skip scanning the blocks previous to this, thus reducing
the total block range. The same strategy is used for outputs.

Author: mpolitzer

internal/evmreader/application_adapter.go

@@ -95,3 +95,7 @@ func (a *ApplicationContractAdapterImpl) RetrieveOutputExecutionEvents(
 	}
 	return events, nil
 }
+
+func (a *ApplicationContractAdapterImpl) GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	return a.application.GetDeploymentBlockNumber(opts)
+}

internal/evmreader/evmreader.go

@@ -57,6 +57,7 @@ type ApplicationContractAdapter interface {
 	RetrieveOutputExecutionEvents(
 		opts *bind.FilterOpts,
 	) ([]*iapplication.IApplicationOutputExecuted, error)
+	GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error)
 }
 
 // Interface for Input reading
@@ -65,6 +66,7 @@ type InputSourceAdapter interface {
 	// by go-ethereum and cannot be used for testing
 	RetrieveInputs(opts *bind.FilterOpts, appAddresses []common.Address, index []*big.Int,
 	) ([]iinputbox.IInputBoxInputAdded, error)
+	GetNumberOfInputs(opts *bind.CallOpts, appContract common.Address) (*big.Int, error)
 }
 
 type SubscriptionError struct {

internal/evmreader/evmreader_test.go

@@ -377,6 +377,11 @@ func (m *MockInputBox) RetrieveInputs(
 	return args.Get(0).([]iinputbox.IInputBoxInputAdded), args.Error(1)
 }
 
+func (m *MockInputBox) GetNumberOfInputs(opts *bind.CallOpts, appContract common.Address) (*big.Int, error) {
+	args := m.Called(opts, appContract)
+	return args.Get(0).(*big.Int), args.Error(1)
+}
+
 // Mock InputReaderRepository
 type MockRepository struct {
 	mock.Mock
@@ -567,6 +572,11 @@ func (m *MockApplicationContract) RetrieveOutputExecutionEvents(
 	return args.Get(0).([]*iapplication.IApplicationOutputExecuted), args.Error(1)
 }
 
+func (m *MockApplicationContract) GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error) {
+	args := m.Called(opts)
+	return args.Get(0).(*big.Int), args.Error(1)
+}
+
 type MockAdapterFactory struct {
 	mock.Mock
 }

internal/evmreader/input.go

@@ -7,12 +7,54 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math/big"
 
 	. "github.com/cartesi/rollups-node/internal/model"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
 
+func findSafeFirstInputBlockToScan(app *appContracts, mostRecentBlockNumber uint64, mostRecentBlockNumberCallOpts *bind.CallOpts) uint64 {
+	var noiBig *big.Int
+	var err error
+
+	// find if the application has ever received any input. sync to present if not
+	noiBig, err = app.inputSource.GetNumberOfInputs(
+		mostRecentBlockNumberCallOpts,
+		app.application.IApplicationAddress,
+	)
+	if err != nil {
+		return app.application.LastInputCheckBlock
+	}
+	if noiBig.Uint64() == 0 {
+		return mostRecentBlockNumber
+	}
+
+	// find if the application has received an input since its deployment. sync to that block if not
+	// we'll need its deployment block number to do that
+	deploymentBlockNumberBig, err := app.applicationContract.GetDeploymentBlockNumber(mostRecentBlockNumberCallOpts)
+	if err != nil {
+		return app.application.LastInputCheckBlock
+	}
+
+	noiBig, err = app.inputSource.GetNumberOfInputs(&bind.CallOpts{
+		BlockNumber: deploymentBlockNumberBig,
+	},
+		app.application.IApplicationAddress,
+	)
+	if err != nil {
+		return app.application.LastInputCheckBlock
+	}
+	if noiBig.Uint64() == 0 {
+		return deploymentBlockNumberBig.Uint64()
+	}
+
+	// TODO(mpolitzer): Applicaiton has inputs previous to its deployment. We can reduce the number of blocks to scan by
+	// doing a binary search over GetNumberOfInputs and finding the block where 0 -> 1 transition happens. As a simpler,
+	// also correct implementation. We return the first possible block an input could appear on.
+	return app.application.IInputBoxBlock
+}
+
 // checkForNewInputs checks if is there new Inputs for all running Applications
 func (r *Service) checkForNewInputs(
 	ctx context.Context,
@@ -25,6 +67,10 @@ func (r *Service) checkForNewInputs(
 
 	r.Logger.Debug("Checking for new inputs")
 
+	mostRecentBlockNumberCallOpts := &bind.CallOpts{
+		BlockNumber: new(big.Int).SetUint64(mostRecentBlockNumber),
+	}
+
 	appsByInputBox := map[common.Address][]appContracts{}
 	for _, app := range applications {
 		if !app.application.HasDataAvailabilitySelector(DataAvailability_InputBox) {
@@ -39,18 +85,27 @@ func (r *Service) checkForNewInputs(
 			"inputbox_address", inputBoxAddress,
 			"most recent block", mostRecentBlockNumber,
 		)
-		appsByLastInputCheckBlock := indexApps(byLastInputCheckBlock, inputBoxApps)
+
+		appsByLastInputCheckBlock := make(map[uint64][]appContracts)
+		for _, app := range inputBoxApps {
+			lastInputCheckBlock := app.application.LastInputCheckBlock
+			if lastInputCheckBlock == 0 { // New application. Find a safe start block to scan for inputs
+				lastInputCheckBlock = findSafeFirstInputBlockToScan(&app,
+					mostRecentBlockNumber,
+					mostRecentBlockNumberCallOpts,
+				) - 1
+				r.Logger.Info("Fast sync application inputs",
+					"application", app.application.Name,
+					"start_block", lastInputCheckBlock,
+				)
+				app.application.LastInputCheckBlock = lastInputCheckBlock
+			}
+			appsByLastInputCheckBlock[lastInputCheckBlock] = append(appsByLastInputCheckBlock[lastInputCheckBlock], app)
+		}
 
 		for lastProcessedBlock, apps := range appsByLastInputCheckBlock {
 			appAddresses := appsToAddresses(apps)
 
-			// Only check blocks starting from the block where the InputBox
-			// contract was deployed as Inputs can be added to that same block
-			inputBoxDeploymentBlock := apps[0].application.IInputBoxBlock
-			if lastProcessedBlock < inputBoxDeploymentBlock {
-				lastProcessedBlock = inputBoxDeploymentBlock - 1
-			}
-
 			if mostRecentBlockNumber > lastProcessedBlock {
 
 				r.Logger.Debug("Checking inputs for applications",
@@ -340,8 +395,3 @@ func (r *Service) readInputsFromBlockchain(
 	}
 	return appInputsMap, nil
 }
-
-// byLastInputCheckBlock key extractor function intended to be used with `indexApps` function
-func byLastInputCheckBlock(app appContracts) uint64 {
-	return app.application.LastInputCheckBlock
-}

internal/evmreader/input_test.go

@@ -4,6 +4,7 @@
 package evmreader
 
 import (
+	"math/big"
 	"time"
 
 	. "github.com/cartesi/rollups-node/internal/model"
@@ -129,6 +130,24 @@ func (s *EvmReaderSuite) TestItReadsInputsFromNewBlocksFilteredByDA() {
 		mock.Anything,
 	).Return(events_1, nil)
 
+	inputBox.Unset("GetNumberOfInputs")
+	inputBox.On(
+		"GetNumberOfInputs",
+		mock.Anything,
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(2), nil)
+
+	applicationContract.On(
+		"GetDeploymentBlockNumber",
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(10), nil)
+
+	inputBox.On(
+		"GetNumberOfInputs",
+		mock.Anything,
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(0), nil)
+
 	// Start service
 	ready := make(chan struct{}, 1)
 	errChannel := make(chan error, 1)
@@ -267,6 +286,24 @@ func (s *EvmReaderSuite) TestItUpdatesLastInputCheckBlockWhenThereIsNoInputs() {
 		mock.Anything,
 	).Return(events_0, nil)
 
+	inputBox.Unset("GetNumberOfInputs")
+	inputBox.On(
+		"GetNumberOfInputs",
+		mock.Anything,
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(1), nil)
+
+	applicationContract.On(
+		"GetDeploymentBlockNumber",
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(10), nil)
+
+	inputBox.On(
+		"GetNumberOfInputs",
+		mock.Anything,
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(0), nil)
+
 	events_1 := []iinputbox.IInputBoxInputAdded{}
 	mostRecentBlockNumber_1 := uint64(0x12)
 	retrieveInputsOpts_1 := bind.FilterOpts{
@@ -350,6 +387,18 @@ func (s *EvmReaderSuite) TestItReadsMultipleInputsFromSingleNewBlock() {
 		mock.Anything,
 	).Return(events_2, nil)
 
+	inputBox.Unset("GetNumberOfInputs")
+	inputBox.On(
+		"GetNumberOfInputs",
+		mock.Anything,
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(2), nil)
+
+	applicationContract.On(
+		"GetDeploymentBlockNumber",
+		mock.Anything,
+	).Return(new(big.Int).SetUint64(10), nil)
+
 	// Prepare Repo
 	s.repository.Unset("ListApplications")
 	s.repository.On(
@@ -450,6 +499,7 @@ func (s *EvmReaderSuite) TestItStartsWhenLasProcessedBlockIsTheMostRecentBlock()
 		IInputBoxBlock:      0x10,
 		EpochLength:         10,
 		LastInputCheckBlock: 0x13,
+		LastOutputCheckBlock:0x13,
 	}}, uint64(1), nil).Once()
 
 	s.repository.Unset("UpdateEventLastCheckBlock")

internal/evmreader/inputsource_adapter.go

@@ -110,3 +110,7 @@ func (i *InputSourceAdapterImpl) RetrieveInputs(
 	}
 	return events, nil
 }
+
+func (i *InputSourceAdapterImpl) GetNumberOfInputs(opts *bind.CallOpts, addr common.Address) (*big.Int, error) {
+	return i.inputbox.GetNumberOfInputs(opts, addr)
+}

internal/evmreader/output.go

@@ -6,11 +6,22 @@ package evmreader
 import (
 	"bytes"
 	"context"
+	"math/big"
 
 	. "github.com/cartesi/rollups-node/internal/model"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 )
 
+// Find the deployment block number of the application. There can be no OutputExecuted events prior to this.
+// Use input box deployment block as a fallback.
+func findSafeFirstOutputBlockToScan(app *appContracts, mostRecentBlockNumberCallOpts *bind.CallOpts) uint64 {
+	deploymentBlockNumberBig, err := app.applicationContract.GetDeploymentBlockNumber(mostRecentBlockNumberCallOpts)
+	if err != nil {
+		return app.application.IInputBoxBlock
+	}
+	return deploymentBlockNumberBig.Uint64()
+}
+
 func (r *Service) checkForOutputExecution(
 	ctx context.Context,
 	apps []appContracts,
@@ -21,11 +32,20 @@ func (r *Service) checkForOutputExecution(
 
 	r.Logger.Debug("Checking for new Output Executed Events", "apps", appAddresses)
 
-	for _, app := range apps {
+	mostRecentBlockNumberCallOpts := &bind.CallOpts{
+		BlockNumber: new(big.Int).SetUint64(mostRecentBlockNumber),
+	}
 
-		// Safeguard: Only check blocks starting from the block where the InputBox
-		// contract was deployed as Inputs can be added to that same block
-		lastOutputCheck := max(app.application.LastOutputCheckBlock, app.application.IInputBoxBlock)
+	for _, app := range apps {
+		lastOutputCheck := app.application.LastOutputCheckBlock
+		if lastOutputCheck == 0 { // New application. Find a safe start block to scan for outputs
+			lastOutputCheck = findSafeFirstOutputBlockToScan(&app, mostRecentBlockNumberCallOpts) - 1
+			r.Logger.Info("Fast sync application outputs",
+				"application", app.application.Name,
+				"start_block", lastOutputCheck,
+			)
+			app.application.LastOutputCheckBlock = lastOutputCheck
+		}
 
 		if mostRecentBlockNumber > lastOutputCheck {
 

internal/evmreader/output_test.go

@@ -39,6 +39,7 @@ func (s *EvmReaderSuite) TestOutputExecution() {
 		DataAvailability:     DataAvailability_InputBox[:],
 		IInputBoxBlock:       0x10,
 		EpochLength:          10,
+		LastInputCheckBlock:  0x01, // don't fast sync inputs
 		LastOutputCheckBlock: 0x10,
 	}}, uint64(1), nil).Once()
 	s.repository.On(