fix: skip blocks for finality

Author: harsh-98

ds/account_quota.go

@@ -41,13 +41,17 @@ func NewAccountQuotaMgr(client core.ClientI) *AccountQuotaMgr {
 	}
 }
 
-func (mdl *AccountQuotaMgr) GetUpdateQuotaEventForAccount(txHash common.Hash) []*UpdateQuotaEvent {
+func (mdl *AccountQuotaMgr) GetUpdateQuotaEventForAccount(txHash common.Hash) map[common.Address][]*UpdateQuotaEvent {
 	mdl.mu.Lock()
 	defer mdl.mu.Unlock()
 	//
 	ans := mdl.events[txHash.Hex()]
 	delete(mdl.events, txHash.Hex())
-	return ans
+	accountToQuotas := map[common.Address][]*UpdateQuotaEvent{}
+	for _, entry := range ans {
+		accountToQuotas[entry.CreditAccount] = append(accountToQuotas[entry.CreditAccount], entry)
+	}
+	return accountToQuotas
 }
 
 func (mdl *AccountQuotaMgr) getUpdateQuotaEvent(txLog types.Log) *UpdateQuotaEvent {

ds/multicall_processor/index.go

@@ -45,11 +45,11 @@ func (v *FacadeAccountAction) SetMulticalls(ops []*schemas.AccountOperation) {
 
 type MulticallProcessorI interface {
 	AddMulticallEvent(operation *schemas.AccountOperation)
-	Start(txHash string, startEvent *schemas.AccountOperation)
+	Start(txHash string, startEvent *schemas.AccountOperation, _ string)
 	AddOpenEvent(openEvent *schemas.AccountOperation)
 	AddCloseEvent(event *schemas.AccountOperation)
 	AddLiquidateEvent(event *schemas.AccountOperation)
 	PopNonMulticallEvents() []*schemas.AccountOperation
 	PopMainActions(txHash string, mgr *ds.AccountQuotaMgr) (facadeActions, openEventWithoutMulticall []*FacadeAccountAction)
-	End(logId uint, debts []pool_v3.ManageDebt, _ string)
+	End(logId uint, debts []pool_v3.ManageDebt, _, _ string)
 }

ds/multicall_processor/multicall_processor_v2.go

@@ -58,7 +58,7 @@ func (p *MultiCallProcessorv2) lastMainAction() *FacadeAccountAction {
 	return nil
 }
 
-func (p *MultiCallProcessorv2) Start(txHash string, startEvent *schemas.AccountOperation) {
+func (p *MultiCallProcessorv2) Start(txHash string, startEvent *schemas.AccountOperation, _ string) {
 	lastMainAction := p.lastMainAction()
 	if p.running {
 		log.Fatalf("Previously started multicall(%s) is not ended for txHash(%s)",
@@ -86,7 +86,7 @@ func (p *MultiCallProcessorv2) AddLiquidateEvent(event *schemas.AccountOperation
 	})
 }
 
-func (p *MultiCallProcessorv2) End(logId uint, _ []pool_v3.ManageDebt, _ string) {
+func (p *MultiCallProcessorv2) End(logId uint, _ []pool_v3.ManageDebt, _ string, _ string) {
 	if !p.running {
 		log.Fatal("Multicall end called though multicall not running")
 	}

ds/multicall_processor/multicall_processor_v3.go

@@ -14,7 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-type MultiCallProcessorv3 struct {
+type MultiCallProcessorv3Unit struct {
 	// borrower            string
 	running            bool // is the multicall running
 	nonMultiCallEvents []*schemas.AccountOperation
@@ -23,7 +23,7 @@ type MultiCallProcessorv3 struct {
 }
 
 // edge case it adds non multicall addCollateral for open credit account
-func (p *MultiCallProcessorv3) AddMulticallEvent(operation *schemas.AccountOperation) {
+func (p *MultiCallProcessorv3Unit) AddMulticallEvent(operation *schemas.AccountOperation) {
 	lastMainAction := p.lastMainAction()
 	//
 	if !p.running { // non multicall
@@ -33,7 +33,7 @@ func (p *MultiCallProcessorv3) AddMulticallEvent(operation *schemas.AccountOpera
 	}
 }
 
-func (p *MultiCallProcessorv3) AddOpenEvent(openEvent *schemas.AccountOperation) {
+func (p *MultiCallProcessorv3Unit) AddOpenEvent(openEvent *schemas.AccountOperation) {
 	if p.noOfOpens > 0 {
 		log.Fatal("2 opencreditaccount event are in same txhash", utils.ToJson(p.facadeActions), utils.ToJson(openEvent))
 	}
@@ -44,14 +44,14 @@ func (p *MultiCallProcessorv3) AddOpenEvent(openEvent *schemas.AccountOperation)
 	p.noOfOpens++
 }
 
-func (p *MultiCallProcessorv3) lastMainAction() *FacadeAccountAction {
+func (p *MultiCallProcessorv3Unit) lastMainAction() *FacadeAccountAction {
 	if len(p.facadeActions) > 0 {
 		return p.facadeActions[len(p.facadeActions)-1]
 	}
 	return nil
 }
 
-func (p *MultiCallProcessorv3) Start(txHash string, startEvent *schemas.AccountOperation) {
+func (p *MultiCallProcessorv3Unit) Start(txHash string, startEvent *schemas.AccountOperation) {
 	lastMainAction := p.lastMainAction()
 	if p.running {
 		log.Fatalf("Previously started multicall(%s) is not ended for txHash(%s)",
@@ -66,22 +66,22 @@ func (p *MultiCallProcessorv3) Start(txHash string, startEvent *schemas.AccountO
 	p.running = true
 }
 
-func (p *MultiCallProcessorv3) AddCloseEvent(event *schemas.AccountOperation) {
+func (p *MultiCallProcessorv3Unit) AddCloseEvent(event *schemas.AccountOperation) {
 	p.facadeActions = append(p.facadeActions, &FacadeAccountAction{
 		Data:  event,
 		ended: true,
 		Type:  GBFacadeCloseEvent,
 	})
 }
-func (p *MultiCallProcessorv3) AddLiquidateEvent(event *schemas.AccountOperation) {
+func (p *MultiCallProcessorv3Unit) AddLiquidateEvent(event *schemas.AccountOperation) {
 	p.facadeActions = append(p.facadeActions, &FacadeAccountAction{
 		Data:  event,
 		Type:  GBFacadev3LiqUpdateEvent,
 		ended: true,
 	})
 }
 
-func (p *MultiCallProcessorv3) End(logId uint, debts []pool_v3.ManageDebt, underlying string) {
+func (p *MultiCallProcessorv3Unit) End(logId uint, debts []pool_v3.ManageDebt, underlying string) {
 	if !p.running {
 		log.Fatal("Multicall end called though multicall not running")
 	}
@@ -133,7 +133,7 @@ func AddManageDebtsToMain(lastMainAction *schemas.AccountOperation, debts []pool
 // - open call without multicalls
 // open call have the multicalls in them
 // liquidated, closed and directly multicalls are separated entries
-func (p *MultiCallProcessorv3) PopMainActions(txHash string, mgr *ds.AccountQuotaMgr) (facadeActions, openEventWithoutMulticall []*FacadeAccountAction) {
+func (p *MultiCallProcessorv3Unit) popMainActions(txHash string, quotas []*ds.UpdateQuotaEvent, mgr *ds.AccountQuotaMgr) (facadeActions, openEventWithoutMulticall []*FacadeAccountAction) {
 	defer func() { p.facadeActions = nil }()
 
 	p.noOfOpens = 0
@@ -142,7 +142,6 @@ func (p *MultiCallProcessorv3) PopMainActions(txHash string, mgr *ds.AccountQuot
 	}
 
 	{
-		quotas := mgr.GetUpdateQuotaEventForAccount(common.HexToHash(txHash))
 		// update quota with session based on accountquotamgr
 		for i := len(facadeActions) - 1; i >= 0; i-- {
 			facade := facadeActions[i]
@@ -164,7 +163,7 @@ func (p *MultiCallProcessorv3) PopMainActions(txHash string, mgr *ds.AccountQuot
 	return
 }
 
-func (p *MultiCallProcessorv3) PopNonMulticallEvents() []*schemas.AccountOperation {
+func (p *MultiCallProcessorv3Unit) PopNonMulticallEvents() []*schemas.AccountOperation {
 	calls := p.nonMultiCallEvents
 	p.nonMultiCallEvents = nil
 	return calls
@@ -191,3 +190,105 @@ func addQuotasToFacade(action *FacadeAccountAction, quotaEvents []*ds.UpdateQuot
 		return action.Data.MultiCall[i].LogId < action.Data.MultiCall[j].LogId
 	})
 }
+
+type MultiCallProcessorv3 struct {
+	units               map[string]*MultiCallProcessorv3Unit
+	facadeAddrToSession map[string]string
+}
+
+func NewMultiCallProcessorv3() *MultiCallProcessorv3 {
+	return &MultiCallProcessorv3{
+		units:               make(map[string]*MultiCallProcessorv3Unit),
+		facadeAddrToSession: map[string]string{},
+	}
+}
+
+func (p *MultiCallProcessorv3) check(operation *schemas.AccountOperation) {
+	if operation.SessionId == "" {
+		log.Fatal("Multicall event without sessionid", utils.ToJson(operation))
+	}
+}
+func (p *MultiCallProcessorv3) AddMulticallEvent(operation *schemas.AccountOperation) {
+	p.check(operation)
+	unit, exists := p.units[operation.SessionId]
+	if !exists {
+		unit = &MultiCallProcessorv3Unit{}
+		p.units[operation.SessionId] = unit
+	}
+	unit.AddMulticallEvent(operation)
+}
+func (p *MultiCallProcessorv3) Start(txHash string, startEvent *schemas.AccountOperation, facadeAddr string) {
+	p.check(startEvent)
+	unit, exists := p.units[startEvent.SessionId]
+	if !exists {
+		unit = &MultiCallProcessorv3Unit{}
+		p.units[startEvent.SessionId] = unit
+	}
+	if _, ok := p.facadeAddrToSession[facadeAddr]; ok {
+		log.Fatal("Two multicalls started for same facade in same txhash without ending previous one", facadeAddr, p.facadeAddrToSession[facadeAddr], startEvent.SessionId, txHash)
+	} else {
+		p.facadeAddrToSession[facadeAddr] = startEvent.SessionId
+	}
+	unit.Start(txHash, startEvent)
+}
+func (p *MultiCallProcessorv3) AddOpenEvent(openEvent *schemas.AccountOperation) {
+	p.check(openEvent)
+	unit, exists := p.units[openEvent.SessionId]
+	if !exists {
+		unit = &MultiCallProcessorv3Unit{}
+		p.units[openEvent.SessionId] = unit
+	}
+	unit.AddOpenEvent(openEvent)
+}
+func (p *MultiCallProcessorv3) AddCloseEvent(event *schemas.AccountOperation) {
+	p.check(event)
+	unit, exists := p.units[event.SessionId]
+	if !exists {
+		unit = &MultiCallProcessorv3Unit{}
+		p.units[event.SessionId] = unit
+	}
+	unit.AddCloseEvent(event)
+}
+func (p *MultiCallProcessorv3) AddLiquidateEvent(event *schemas.AccountOperation) {
+	p.check(event)
+	unit, exists := p.units[event.SessionId]
+	if !exists {
+		unit = &MultiCallProcessorv3Unit{}
+		p.units[event.SessionId] = unit
+	}
+	unit.AddLiquidateEvent(event)
+}
+func (p *MultiCallProcessorv3) PopNonMulticallEvents() []*schemas.AccountOperation {
+	var calls []*schemas.AccountOperation
+	for _, unit := range p.units {
+		calls = append(calls, unit.PopNonMulticallEvents()...)
+	}
+	return calls
+}
+func (p *MultiCallProcessorv3) PopMainActions(txHash string, mgr *ds.AccountQuotaMgr) (facadeActions, openEventWithoutMulticall []*FacadeAccountAction) {
+	quotas := mgr.GetUpdateQuotaEventForAccount(common.HexToHash(txHash))
+	for sessionId, unit := range p.units {
+		facade, openWithoutMC := unit.popMainActions(txHash, quotas[common.HexToAddress(strings.Split(sessionId, "_")[0])], mgr)
+		facadeActions = append(facadeActions, facade...)
+		openEventWithoutMulticall = append(openEventWithoutMulticall, openWithoutMC...)
+	}
+	p.units = make(map[string]*MultiCallProcessorv3Unit)
+	if len(p.facadeAddrToSession) != 0 {
+		log.Fatal("facadeAddrToSession not empty after popping main actions", utils.ToJson(p.facadeAddrToSession))
+	}
+	return
+
+}
+func (p *MultiCallProcessorv3) End(logId uint, debts []pool_v3.ManageDebt, underlyingtoken string, facadeAddr string) {
+	sessionId, ok := p.facadeAddrToSession[facadeAddr]
+	if !ok {
+		log.Fatal("Multicall end called though no multicall was started for facadeAddr", facadeAddr)
+	}
+	delete(p.facadeAddrToSession, facadeAddr)
+	//
+	unit, exists := p.units[sessionId]
+	if !exists {
+		log.Fatal("Multicall end called though no multicall was started for sessionid", sessionId)
+	}
+	unit.End(logId, debts, underlyingtoken)
+}

engine/index.go

@@ -108,8 +108,10 @@ func (e *Engine) getLastSyncedTill() int64 {
 
 func (e *Engine) SyncHandler() {
 	e.init()
-	latestBlockNum := e.GetLatestFinalizedBlock(2)
-	// latestBlockNum = 50768558
+	blocksToSkipForfinality := core.BlockPer(core.GetBaseChainId(e.Client), time.Minute) / 2
+	latestBlockNum := e.GetLatestFinalizedBlock(blocksToSkipForfinality)
+	// latestBlockNum = 23624143
+
 	lastSyncedTill := e.getLastSyncedTill()
 	e.syncedBlock.Store(lastSyncedTill)
 	//
@@ -120,7 +122,8 @@ func (e *Engine) SyncHandler() {
 	}
 	for {
 		latestBlockNum = e.GetLatestFinalizedBlock(2)
-		// latestBlockNum = 50768558
+		// latestBlockNum = 23624143
+
 		e.SyncAndFlush(latestBlockNum)
 		log.Infof("Synced till %d sleeping for 2 mins", latestBlockNum)
 		time.Sleep(2 * time.Minute) // on kovan 5 blocks in 1 min , sleep for 5 mins

go.mod

@@ -5,7 +5,7 @@ go 1.23
 // toolchain go1.23.2
 
 require (
-	github.com/Gearbox-protocol/sdk-go v0.0.0-20251015055252-92dd2d7b6903
+	github.com/Gearbox-protocol/sdk-go v0.0.0-20251021075349-8001f420e823
 	github.com/ethereum/go-ethereum v1.13.14
 	github.com/go-playground/validator/v10 v10.4.1
 	github.com/google/go-cmp v0.6.0

go.sum

@@ -6,8 +6,8 @@ github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ=
 github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
-github.com/Gearbox-protocol/sdk-go v0.0.0-20251015055252-92dd2d7b6903 h1:TO4Acste+rQEX0Nynfr6RVxNqwWjlpGM7aoV1bcDrxc=
-github.com/Gearbox-protocol/sdk-go v0.0.0-20251015055252-92dd2d7b6903/go.mod h1:MZsiiSAwDdnHY6GEILYtHEqhb9wmbUUE34UBQgNlUyM=
+github.com/Gearbox-protocol/sdk-go v0.0.0-20251021075349-8001f420e823 h1:5yuKbokqIr7EZGMoSaJs7lGyTxQIyW62AkKxpClwx+4=
+github.com/Gearbox-protocol/sdk-go v0.0.0-20251021075349-8001f420e823/go.mod h1:MZsiiSAwDdnHY6GEILYtHEqhb9wmbUUE34UBQgNlUyM=
 github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
 github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
 github.com/OffchainLabs/go-ethereum v1.13.4-0.20240313010929-e5d8587e7227 h1:+/3TrD+q+BP36jGj2Bycdmrc/joKLNbc5ImePQzKRLM=

models/credit_manager/cm_common/facade_actions.go

@@ -22,13 +22,14 @@ func (mdl *CommonCMAdapter) fixFacadeActionStructureViaTenderlyCalls(mainCalls [
 	facadeActions []*mpi.FacadeAccountAction) (result []*mpi.FacadeAccountAction) { // facadeEvents from rpc, mainCalls from tenderly
 	if len(mainCalls) > len(facadeActions) {
 
-	log.Warn(utils.ToJson(mainCalls) , utils.ToJson(facadeActions))
-	log.Warnf("Len of calls(%d) can't be more than separated close/liquidate and multicall(%d).",
+		log.Warn(utils.ToJson(mainCalls), utils.ToJson(facadeActions))
+		log.Warnf("Len of calls(%d) can't be more than separated close/liquidate and multicall(%d).",
 			len(mainCalls), len(facadeActions),
 		)
 		if "0x6355aa8c94e2db37e99bb6702dd66ef189d1d356cc3149081be247f72f526c8d" == facadeActions[0].Data.TxHash {
 			//mainCalls = []*ds.FacadeCallNameWithMulticall{mainCalls[1]}
-	}}
+		}
+	}
 	//
 	var ind int
 	for _, mainCall := range mainCalls[:utils.Min(len(facadeActions), len(mainCalls))] { // TOOD fix
@@ -75,7 +76,6 @@ func (mdl *CommonCMAdapter) validateAndSaveFacadeActions(version core.VersionTyp
 	facadeActions []*mpi.FacadeAccountAction,
 	mainCalls []*ds.FacadeCallNameWithMulticall,
 	nonMultiCallExecuteEvents []ds.ExecuteParams) {
-
 	executeParams := []ds.ExecuteParams{} // non multicall and multicall execute orders for a tx to be compared with call trace
 	for ind, _mainAction := range facadeActions {
 		mainEvent := _mainAction.Data

models/credit_manager/cm_v2/v2.go

@@ -76,9 +76,9 @@ func (mdl *CMv2) checkLogV2(txLog types.Log) {
 			Dapp:        txLog.Address.Hex(),
 			LogId:       txLog.Index,
 			Action:      "MultiCallStarted(address)",
-		})
+		}, mdl.Address) // facade addr
 	case core.Topic("MultiCallFinished()"):
-		mdl.MulticallMgr.End(txLog.Index, nil, mdl.GetUnderlyingToken())
+		mdl.MulticallMgr.End(txLog.Index, nil, mdl.GetUnderlyingToken(), mdl.Address)
 	case core.Topic("IncreaseBorrowedAmount(address,uint256)"):
 		increaseBorrowEvent, err := mdl.facadeContractv2.ParseIncreaseBorrowedAmount(txLog)
 		if err != nil {

models/credit_manager/cm_v3/cm_state.go

@@ -25,7 +25,7 @@ type Cmv3State struct {
 
 func NewCmv3State(adapter *ds.SyncAdapter) Cmv3State {
 	return Cmv3State{
-		CommonCMAdapter:  cm_common.NewCommonCMAdapter(adapter, &mp.MultiCallProcessorv3{}),
+		CommonCMAdapter:  cm_common.NewCommonCMAdapter(adapter, mp.NewMultiCallProcessorv3()),
 		allowedProtocols: map[string]bool{},
 		whosAccount:      map[string]AccountOwner{},
 	}