Use in-memory cache to speed up delegation access.

Author: Jiri Malek

internal/repository/cache/delegation.go

@@ -0,0 +1,57 @@
+// Package cache implements bridge to fast in-memory object cache.
+package cache
+
+import (
+	"fantom-api-graphql/internal/types"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"strings"
+)
+
+// delegationCacheKey generates cache key for the given delegation.
+func delegationCacheKey(adr common.Address, valID *hexutil.Big) string {
+	var key strings.Builder
+	key.WriteString("dlg")
+	key.WriteString(adr.String())
+	key.WriteString("to")
+	key.WriteString(valID.String())
+	return key.String()
+}
+
+// PullDelegation tries to pull delegation from the given address to the given validator
+// from internal in-memory cache.
+func (b *MemBridge) PullDelegation(adr common.Address, valID *hexutil.Big) *types.Delegation {
+	// try to get the account data from the cache
+	data, err := b.cache.Get(delegationCacheKey(adr, valID))
+	if err != nil {
+		return nil
+	}
+
+	// do we have the data?
+	dlg := new(types.Delegation)
+	if err := dlg.UnmarshalBSON(data); err != nil {
+		b.log.Criticalf("can not decode delegation data from in-memory cache; %s", err.Error())
+		return nil
+	}
+	return dlg
+}
+
+// PushDelegation stored the given delegation in memory cache.
+func (b *MemBridge) PushDelegation(dlg *types.Delegation) {
+	// no need to store nil
+	if dlg == nil {
+		return
+	}
+
+	// encode account
+	data, err := dlg.MarshalBSON()
+	if err != nil {
+		b.log.Criticalf("can not marshal delegation of %s to #%d; %s", dlg.Address.String(), dlg.ToStakerId.ToInt().Uint64(), err.Error())
+		return
+	}
+
+	// set the data to cache by block number
+	if err := b.cache.Set(delegationCacheKey(dlg.Address, dlg.ToStakerId), data); err != nil {
+		b.log.Criticalf("can not cache delegation of %s to #%d; %s", dlg.Address.String(), dlg.ToStakerId.ToInt().Uint64(), err.Error())
+	}
+}

internal/repository/db/delegation.go

@@ -60,6 +60,11 @@ func (db *MongoDbBridge) Delegation(addr *common.Address, valID *hexutil.Big) (*
 		{types.FiDelegationToValidator, valID.String()},
 	})
 
+	// do we have the data?
+	if sr.Err() != nil {
+		return nil, sr.Err()
+	}
+
 	// try to decode
 	var dlg types.Delegation
 	if err := sr.Decode(&dlg); err != nil {

internal/repository/repository.go

@@ -594,9 +594,6 @@ type proxy struct {
 
 	// service orchestrator reference
 	orc *orchestrator
-
-	// map of delegation balances for updates control
-	stakedAmounts *StakeAmountMap
 }
 
 // newRepository creates new instance of Repository implementation, namely proxy structure.
@@ -621,9 +618,6 @@ func newRepository() Repository {
 
 		// keep reference to the SOL compiler
 		solCompiler: cfg.Compiler.DefaultSolCompilerPath,
-
-		// map of delegation amounts
-		stakedAmounts: NewStakeAmountMap(),
 	}
 
 	// make the service orchestrator and start it's job

internal/repository/sfc_delegation.go

@@ -38,7 +38,7 @@ func (p *proxy) StoreDelegation(dl *types.Delegation) error {
 }
 
 // UpdateDelegationBalance updates active balance of the given delegation.
-func (p *proxy) UpdateDelegationBalance(addr *common.Address, valID *hexutil.Big, unknown func(*big.Int) error) error {
+func (p *proxy) UpdateDelegationBalance(addr *common.Address, valID *hexutil.Big, unknownDelegation func(*big.Int) error) error {
 	// pull the current value
 	val, err := p.DelegationAmountStaked(addr, valID)
 	if err != nil {
@@ -54,8 +54,11 @@ func (p *proxy) UpdateDelegationBalance(addr *common.Address, valID *hexutil.Big
 
 	// unknown delegation detected?
 	if err == db.ErrUnknownDelegation {
-		return unknown(val)
+		p.log.Errorf("delegation %s to %d not known yet", addr.String(), valID.ToInt().Uint64())
+		return unknownDelegation(val)
 	}
+
+	// some other error
 	p.log.Errorf("delegation %s to %d update failed; %s", addr.String(), valID.ToInt().Uint64(), err.Error())
 	return err
 }
@@ -68,32 +71,39 @@ func (p *proxy) updateDelegationBalance(addr *common.Address, valID *hexutil.Big
 		return err
 	}
 
-	// do we need to update?
+	// do we need to update? if the amount did not change, skip the update
 	if dlg.AmountStaked.ToInt().Cmp(amo) == 0 {
 		return nil
 	}
 
-	// update the delegation in cache
+	// update the delegation in DB and memory
 	dlg.AmountDelegated = (*hexutil.Big)(amo)
-
-	// perform the update
-	return p.db.UpdateDelegationBalance(addr, valID, dlg.AmountDelegated)
+	err = p.db.UpdateDelegationBalance(addr, valID, dlg.AmountDelegated)
+	if nil == err {
+		p.cache.PushDelegation(dlg)
+	}
+	return err
 }
 
 // Delegation returns a detail of delegation for the given address.
-func (p *proxy) Delegation(addr *common.Address, valID *hexutil.Big) (*types.Delegation, error) {
+func (p *proxy) Delegation(adr *common.Address, valID *hexutil.Big) (*types.Delegation, error) {
 	// log what we do
-	p.log.Debugf("loading delegation of %s to #%d", addr.String(), valID.ToInt().Uint64())
+	p.log.Debugf("accessing delegation of %s to #%d", adr.String(), valID.ToInt().Uint64())
 
 	// try cache first
+	dlg := p.cache.PullDelegation(*adr, valID)
+	if dlg != nil {
+		return dlg, nil
+	}
 
-	// pull from DB instead
-	dlg, err := p.db.Delegation(addr, valID)
+	// pull from DB instead; do we actually have it?
+	dlg, err := p.db.Delegation(adr, valID)
 	if err != nil {
 		return nil, err
 	}
 
 	// store to cache for future reference
+	p.cache.PushDelegation(dlg)
 	return dlg, nil
 }