can configure data source priorities, allow to translate URL form dat…

…a committee, elderberry-validium not implemented

dataavailability/dataavailability.go

@@ -57,6 +57,7 @@ func New(
 		dataSourcePriority: priority,
 	}
 	if len(da.dataSourcePriority) == 0 {
+		log.Infof("Data availability priority not set, using default: %v", DefaultPriority)
 		da.dataSourcePriority = DefaultPriority
 	}
 	err := da.backend.Init()
@@ -87,7 +88,6 @@ func (d *DataAvailability) GetBatchL2Data(batchNums []uint64, batchHashes []comm
 
 	for _, p := range d.dataSourcePriority {
 		switch p {
-
 		case Trusted:
 			if !d.isTrustedSequencer {
 				data, err := d.rpcData(batchNums, batchHashes, d.zkEVMClient.BatchesByNumbers)

dataavailability/datacommittee/datacommittee.go

@@ -13,6 +13,7 @@ import (
 	daTypes "github.com/0xPolygon/cdk-data-availability/types"
 	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/etherman/smartcontracts/polygondatacommittee"
 	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/log"
+	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/translator"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -21,6 +22,7 @@ import (
 )
 
 const unexpectedHashTemplate = "missmatch on transaction data. Expected hash %s, actual hash: %s"
+const translateContextName = "dataCommittee"
 
 // DataCommitteeMember represents a member of the Data Committee
 type DataCommitteeMember struct {
@@ -52,6 +54,7 @@ type DataCommitteeBackend struct {
 	committeeMembers        []DataCommitteeMember
 	selectedCommitteeMember int
 	ctx                     context.Context
+	Translator              translator.Translator
 }
 
 // New creates an instance of DataCommitteeBackend
@@ -60,6 +63,7 @@ func New(
 	dataCommitteeAddr common.Address,
 	privKey *ecdsa.PrivateKey,
 	dataCommitteeClientFactory client.Factory,
+	translator translator.Translator,
 ) (*DataCommitteeBackend, error) {
 	ethClient, err := ethclient.Dial(l1RPCURL)
 	if err != nil {
@@ -75,6 +79,7 @@ func New(
 		privKey:                    privKey,
 		dataCommitteeClientFactory: dataCommitteeClientFactory,
 		ctx:                        context.Background(),
+		Translator:                 translator,
 	}, nil
 }
 
@@ -116,7 +121,7 @@ func (d *DataCommitteeBackend) GetBatchL2Data(hash common.Hash) ([]byte, error)
 	found := false
 	for !found && intialMember != -1 {
 		member := d.committeeMembers[d.selectedCommitteeMember]
-		log.Infof("trying to get data from %s at %s", member.Addr.Hex(), member.URL)
+		log.Debugf("trying to get data from %s at %s", member.Addr.Hex(), member.URL)
 		c := d.dataCommitteeClientFactory.New(member.URL)
 		data, err := c.GetOffChainData(d.ctx, hash)
 		if err != nil {
@@ -145,6 +150,7 @@ func (d *DataCommitteeBackend) GetBatchL2Data(hash common.Hash) ([]byte, error)
 			}
 			continue
 		}
+		log.Debugf("got data from %s at %s: dataHash: %s", member.Addr.Hex(), member.URL, actualTransactionsHash.Hex())
 		return data, nil
 	}
 	if err := d.Init(); err != nil {
@@ -309,6 +315,7 @@ func (d *DataCommitteeBackend) getCurrentDataCommitteeMembers() ([]DataCommittee
 		if err != nil {
 			return nil, fmt.Errorf("error getting Members %d from L1 SC: %w", i, err)
 		}
+		member.Url = d.Translator.Translate(translateContextName, member.Url)
 		members = append(members, DataCommitteeMember{
 			Addr: member.Addr,
 			URL:  member.Url,

etherman/config.go

@@ -1,6 +1,10 @@
 package etherman
 
-import "github.com/ethereum/go-ethereum/common"
+import (
+	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/dataavailability"
+	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/translator"
+	"github.com/ethereum/go-ethereum/common"
+)
 
 // Config represents the configuration of the etherman
 type Config struct {
@@ -15,6 +19,9 @@ type Config struct {
 type ValidiumConfig struct {
 	Enabled             bool   `mapstructure:"Enabled"`
 	TrustedSequencerURL string `mapstructure:"TrustedSequencerURL"`
+	// DataSourcePriority defines the order in which L2 batch should be retrieved: local, trusted, external
+	DataSourcePriority []dataavailability.DataSourcePriority `mapstructure:"DataSourcePriority"`
+	Translator         translator.Config                     `mapstructure:"Translator"`
 }
 
 type ContractConfig struct {

etherman/etherman_validium.go

@@ -11,6 +11,7 @@ import (
 	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/etherman/smartcontracts/etrogvalidiumpolygonzkevm"
 	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/jsonrpcclient"
 	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/log"
+	"github.com/0xPolygonHermez/zkevm-synchronizer-l1/translator"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -39,14 +40,16 @@ func NewEthermanValidium(cfg Config, ethClient bind.ContractBackend) (*EthermanV
 	if err != nil {
 		return nil, err
 	}
+	translator := translator.NewTranslatorImpl()
+	translator.AddConfigRules(cfg.Validium.Translator)
 
 	res := &EthermanValidium{
 		Cfg:                              cfg,
 		ZkEVMValidiumContract:            zkevmValidum,
 		DataAvailabilityProtocolContract: daContract,
 		DataAvailabilityProtocolAddress:  DAProtocolAddr,
 	}
-	da, err := res.newDataAvailabilityClient()
+	da, err := res.newDataAvailabilityClient(translator, cfg.Validium.DataSourcePriority)
 	if err != nil {
 		return nil, err
 	}
@@ -96,20 +99,14 @@ func (ev *EthermanValidium) GetDAProtocolName() (string, error) {
 	return ev.DataAvailabilityProtocolContract.GetProcotolName(&bind.CallOpts{Pending: false})
 }
 
-func (ev *EthermanValidium) newDataAvailabilityClient() (*dataavailability.DataAvailability, error) {
-	var (
-		dataSourcePriority []dataavailability.DataSourcePriority
-	)
+func (ev *EthermanValidium) newDataAvailabilityClient(translator translator.Translator, dataSourcePriority []dataavailability.DataSourcePriority) (*dataavailability.DataAvailability, error) {
 	trustedURL, err := ev.GetTrustedSequencerURL()
 	if err != nil {
 		return nil, fmt.Errorf("error getting trusted sequencer URL: %w", err)
 	}
 	log.Debugf("Creating Trusted Sequencer Client with URL: %s", trustedURL)
 	trustedRPCClient := jsonrpcclient.NewClient(trustedURL)
 
-	// TODO: Configurable data source priority
-	dataSourcePriority = dataavailability.DefaultPriority
-
 	// Backend specific config
 	daProtocolName, err := ev.GetDAProtocolName()
 	if err != nil {
@@ -131,6 +128,7 @@ func (ev *EthermanValidium) newDataAvailabilityClient() (*dataavailability.DataA
 			dacAddr,
 			pk,
 			dataCommitteeClient.NewFactory(),
+			translator,
 		)
 		if err != nil {
 			return nil, err

synchronizer/synchronizer.go

@@ -151,6 +151,7 @@ func NewSynchronizer(ctx context.Context, config config.Config) (Synchronizer, e
 		log.Error(err)
 		return nil, err
 	}
+
 	etherman, err := etherman.NewClient(config.Etherman)
 	if err != nil {
 		log.Error("Error creating etherman", err)

translator/config.go

@@ -0,0 +1,11 @@
+package translator
+
+type ConfigRuleFullMatch struct {
+	ContextName string `mapstructure:"ContextName"`
+	Old         string `mapstructure:"Old"`
+	New         string `mapstructure:"New"`
+}
+
+type Config struct {
+	FullMatchRules []ConfigRuleFullMatch `mapstructure:"UniversalFullRules"`
+}

translator/translator.go

@@ -0,0 +1,5 @@
+package translator
+
+type Translator interface {
+	Translate(contextName string, data string) string
+}

translator/translator_impl.go

@@ -0,0 +1,69 @@
+package translator
+
+import "github.com/0xPolygonHermez/zkevm-synchronizer-l1/log"
+
+type TranslatorFullMatchRule struct {
+	// If null match any context
+	ContextName *string
+	// If null match any data
+	FullMatchString string
+	NewString       string
+}
+
+func (t *TranslatorFullMatchRule) Match(contextName string, data string) bool {
+	if t.ContextName != nil && *t.ContextName != contextName {
+		return false
+	}
+	if t.FullMatchString != data {
+		return false
+	}
+	return true
+}
+
+func (t *TranslatorFullMatchRule) Translate(contextName string, data string) string {
+	return t.NewString
+}
+
+func NewTranslatorFullMatchRule(contextName *string, fullMatchString string, newString string) *TranslatorFullMatchRule {
+	return &TranslatorFullMatchRule{
+		ContextName:     contextName,
+		FullMatchString: fullMatchString,
+		NewString:       newString,
+	}
+}
+
+type TranslatorImpl struct {
+	FullMatchRules []TranslatorFullMatchRule
+}
+
+func NewTranslatorImpl() *TranslatorImpl {
+	return &TranslatorImpl{
+		FullMatchRules: []TranslatorFullMatchRule{},
+	}
+}
+
+func (t *TranslatorImpl) Translate(contextName string, data string) string {
+	for _, rule := range t.FullMatchRules {
+		if rule.Match(contextName, data) {
+			translated := rule.Translate(contextName, data)
+			log.Debugf("Translated (ctxName=%s) %s to %s", contextName, data, translated)
+			return translated
+		}
+	}
+	return data
+}
+
+func (t *TranslatorImpl) AddRule(rule TranslatorFullMatchRule) {
+	t.FullMatchRules = append(t.FullMatchRules, rule)
+}
+
+func (t *TranslatorImpl) AddConfigRules(cfg Config) {
+	for _, v := range cfg.FullMatchRules {
+		var contextName *string
+		if v.ContextName != "" {
+			contextName = &v.ContextName
+		}
+		rule := NewTranslatorFullMatchRule(contextName, v.Old, v.New)
+		t.AddRule(*rule)
+	}
+}