feat: update middleware submodule to v1.0.3-testnet-slashing release

Makefile

@@ -63,7 +63,7 @@ core_default := "DelegationManager IRewardsCoordinator StrategyManager EigenPod
 core_location := "./lib/eigenlayer-middleware/lib/eigenlayer-contracts"
 core_bindings_location := "../../../../bindings"
 
-middleware_default := "RegistryCoordinator IndexRegistry OperatorStateRetriever StakeRegistry BLSApkRegistry IBLSSignatureChecker ServiceManagerBase IERC20"
+middleware_default := "RegistryCoordinator SlashingRegistryCoordinator IndexRegistry OperatorStateRetriever StakeRegistry BLSApkRegistry SocketRegistry IBLSSignatureChecker ServiceManagerBase IERC20"
 middleware_location := "./lib/eigenlayer-middleware"
 middleware_bindings_location := "../../bindings"
 
@@ -113,7 +113,7 @@ eigenpod-bindings: ## generates contract bindings for eigenpod
 
 .PHONY: bindings
 bindings: ## generates all contract bindings
-	rm -rf bindings/* && make core-bindings middleware-bindings sdk-bindings eigenpod-bindings
+	rm -rf contracts/bindings/* && make core-bindings middleware-bindings sdk-bindings eigenpod-bindings
 
 
 ___CONTRACTS___: ## 

chainio/clients/avsregistry/bindings.go

@@ -47,7 +47,6 @@ func NewBindingsFromConfig(
 	var (
 		err error
 
-		serviceManagerAddr    gethcommon.Address
 		stakeRegistryAddr     gethcommon.Address
 		blsApkRegistryAddr    gethcommon.Address
 		indexRegistryAddr     gethcommon.Address
@@ -74,18 +73,6 @@ func NewBindingsFromConfig(
 			return nil, utils.WrapError("Failed to create BLSRegistryCoordinator contract", err)
 		}
 
-		serviceManagerAddr, err = contractBlsRegistryCoordinator.ServiceManager(&bind.CallOpts{})
-		if err != nil {
-			return nil, utils.WrapError("Failed to fetch ServiceManager address", err)
-		}
-		contractServiceManager, err = servicemanager.NewContractServiceManagerBase(
-			serviceManagerAddr,
-			client,
-		)
-		if err != nil {
-			return nil, utils.WrapError("Failed to create ServiceManager contract", err)
-		}
-
 		stakeRegistryAddr, err = contractBlsRegistryCoordinator.StakeRegistry(&bind.CallOpts{})
 		if err != nil {
 			return nil, utils.WrapError("Failed to fetch StakeRegistry address", err)
@@ -123,10 +110,6 @@ func NewBindingsFromConfig(
 		if err != nil {
 			return nil, utils.WrapError("Failed to get DelegationManager address", err)
 		}
-		avsDirectoryAddr, err = contractServiceManager.AvsDirectory(&bind.CallOpts{})
-		if err != nil {
-			return nil, utils.WrapError("Failed to get AvsDirectory address", err)
-		}
 
 		delegationManager, err := contractDelegationManager.NewContractDelegationManager(
 			delegationManagerAddr,
@@ -140,6 +123,23 @@ func NewBindingsFromConfig(
 		}
 	}
 
+	if isZeroAddress(cfg.ServiceManagerAddress) {
+		logger.Debug("ServiceManager address not provided, the calls to the contract will not work")
+	} else {
+		contractServiceManager, err = servicemanager.NewContractServiceManagerBase(
+			cfg.ServiceManagerAddress,
+			client,
+		)
+		if err != nil {
+			return nil, utils.WrapError("Failed to create ServiceManager contract", err)
+		}
+
+		avsDirectoryAddr, err = contractServiceManager.AvsDirectory(&bind.CallOpts{})
+		if err != nil {
+			return nil, utils.WrapError("Failed to get AvsDirectory address", err)
+		}
+	}
+
 	if isZeroAddress(cfg.OperatorStateRetrieverAddress) {
 		logger.Debug("OperatorStateRetriever address not provided, the calls to the contract will not work")
 	} else {
@@ -154,7 +154,7 @@ func NewBindingsFromConfig(
 	}
 
 	return &ContractBindings{
-		ServiceManagerAddr:         serviceManagerAddr,
+		ServiceManagerAddr:         cfg.ServiceManagerAddress,
 		RegistryCoordinatorAddr:    cfg.RegistryCoordinatorAddress,
 		StakeRegistryAddr:          stakeRegistryAddr,
 		BlsApkRegistryAddr:         blsApkRegistryAddr,

chainio/clients/avsregistry/reader.go

@@ -28,6 +28,9 @@ var DefaultQueryBlockRange = big.NewInt(10_000)
 type Config struct {
 	RegistryCoordinatorAddress    common.Address
 	OperatorStateRetrieverAddress common.Address
+
+	/// The address of the ServiceManager contract.
+	ServiceManagerAddress common.Address
 }
 
 // The ChainReader provides methods to call the

chainio/clients/avsregistry/writer.go

@@ -158,7 +158,7 @@ func (w *ChainWriter) RegisterOperatorInQuorumWithAVSRegistryCoordinator(
 	)
 	G1pubkeyBN254 := chainioutils.ConvertToBN254G1Point(blsKeyPair.GetPubKeyG1())
 	G2pubkeyBN254 := chainioutils.ConvertToBN254G2Point(blsKeyPair.GetPubKeyG2())
-	pubkeyRegParams := regcoord.IBLSApkRegistryPubkeyRegistrationParams{
+	pubkeyRegParams := regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams{
 		PubkeyRegistrationSignature: signedMsg,
 		PubkeyG1:                    G1pubkeyBN254,
 		PubkeyG2:                    G2pubkeyBN254,
@@ -260,15 +260,15 @@ func (w *ChainWriter) RegisterOperator(
 	)
 	G1pubkeyBN254 := chainioutils.ConvertToBN254G1Point(blsKeyPair.GetPubKeyG1())
 	G2pubkeyBN254 := chainioutils.ConvertToBN254G2Point(blsKeyPair.GetPubKeyG2())
-	pubkeyRegParams := regcoord.IBLSApkRegistryPubkeyRegistrationParams{
+	pubkeyRegParams := regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams{
 		PubkeyRegistrationSignature: signedMsg,
 		PubkeyG1:                    G1pubkeyBN254,
 		PubkeyG2:                    G2pubkeyBN254,
 	}
 
 	// generate a random salt and 1 hour expiry for the signature
-	var operatorToAvsRegistrationSigSalt [32]byte
-	_, err = rand.Read(operatorToAvsRegistrationSigSalt[:])
+	var signatureSalt [32]byte
+	_, err = rand.Read(signatureSalt[:])
 	if err != nil {
 		return nil, err
 	}
@@ -282,17 +282,17 @@ func (w *ChainWriter) RegisterOperator(
 		return nil, err
 	}
 	sigValidForSeconds := int64(60 * 60) // 1 hour
-	operatorToAvsRegistrationSigExpiry := new(
-		big.Int,
-	).Add(new(big.Int).SetUint64(curBlock.Time()), big.NewInt(sigValidForSeconds))
+
+	curTime := new(big.Int).SetUint64(curBlock.Time())
+	signatureExpiry := new(big.Int).Add(curTime, big.NewInt(sigValidForSeconds))
 
 	// params to register operator in delegation manager's operator-avs mapping
 	msgToSign, err := w.elReader.CalculateOperatorAVSRegistrationDigestHash(
 		ctx,
 		operatorAddr,
 		w.serviceManagerAddr,
-		operatorToAvsRegistrationSigSalt,
-		operatorToAvsRegistrationSigExpiry,
+		signatureSalt,
+		signatureExpiry,
 	)
 	if err != nil {
 		return nil, err
@@ -307,8 +307,8 @@ func (w *ChainWriter) RegisterOperator(
 	operatorSignature[64] += 27
 	operatorSignatureWithSaltAndExpiry := regcoord.ISignatureUtilsSignatureWithSaltAndExpiry{
 		Signature: operatorSignature,
-		Salt:      operatorToAvsRegistrationSigSalt,
-		Expiry:    operatorToAvsRegistrationSigExpiry,
+		Salt:      signatureSalt,
+		Expiry:    signatureExpiry,
 	}
 
 	noSendTxOpts, err := w.txMgr.GetNoSendTxOpts()

chainio/clients/avsregistry/writer_test.go

@@ -34,6 +34,7 @@ func TestWriterMethods(t *testing.T) {
 	config := avsregistry.Config{
 		RegistryCoordinatorAddress:    contractAddrs.RegistryCoordinator,
 		OperatorStateRetrieverAddress: contractAddrs.OperatorStateRetriever,
+		ServiceManagerAddress:         contractAddrs.ServiceManager,
 	}
 
 	chainWriter, err := testclients.NewTestAvsRegistryWriterFromConfig(anvilHttpEndpoint, operatorPrivateKeyHex, config)

chainio/clients/builder.go

@@ -28,6 +28,9 @@ type BuildAllConfig struct {
 	OperatorStateRetrieverAddr string
 	AvsName                    string
 	PromMetricsIpPortAddress   string
+
+	/// The address of the ServiceManager contract.
+	ServiceManagerAddress string
 }
 
 // ReadClients is a struct that holds only the read clients for interacting with the AVS and EL contracts.
@@ -77,12 +80,17 @@ func BuildReadClients(
 		return nil, utils.WrapError("Failed to create Eth WS client", err)
 	}
 
+	avsCfg := avsregistry.Config{
+		RegistryCoordinatorAddress:    gethcommon.HexToAddress(config.RegistryCoordinatorAddr),
+		OperatorStateRetrieverAddress: gethcommon.HexToAddress(config.OperatorStateRetrieverAddr),
+	}
+	if config.ServiceManagerAddress != "" {
+		avsCfg.ServiceManagerAddress = gethcommon.HexToAddress(config.ServiceManagerAddress)
+	}
+
 	// creating AVS clients: Reader
 	avsRegistryChainReader, avsRegistryChainSubscriber, avsRegistryContractBindings, err := avsregistry.BuildReadClients(
-		avsregistry.Config{
-			RegistryCoordinatorAddress:    gethcommon.HexToAddress(config.RegistryCoordinatorAddr),
-			OperatorStateRetrieverAddress: gethcommon.HexToAddress(config.OperatorStateRetrieverAddr),
-		},
+		avsCfg,
 		ethHttpClient,
 		ethWsClient,
 		logger,
@@ -168,13 +176,17 @@ func BuildAll(
 		return nil, utils.WrapError("Failed to create transaction sender", err)
 	}
 	txMgr := txmgr.NewSimpleTxManager(pkWallet, ethHttpClient, logger, addr)
+	avsCfg := avsregistry.Config{
+		RegistryCoordinatorAddress:    gethcommon.HexToAddress(config.RegistryCoordinatorAddr),
+		OperatorStateRetrieverAddress: gethcommon.HexToAddress(config.OperatorStateRetrieverAddr),
+	}
+	if config.ServiceManagerAddress != "" {
+		avsCfg.ServiceManagerAddress = gethcommon.HexToAddress(config.ServiceManagerAddress)
+	}
 
 	// creating AVS clients: Reader and Writer
 	avsRegistryChainReader, avsRegistryChainSubscriber, avsRegistryChainWriter, avsRegistryContractBindings, err := avsregistry.BuildClients(
-		avsregistry.Config{
-			RegistryCoordinatorAddress:    gethcommon.HexToAddress(config.RegistryCoordinatorAddr),
-			OperatorStateRetrieverAddress: gethcommon.HexToAddress(config.OperatorStateRetrieverAddr),
-		},
+		avsCfg,
 		ethHttpClient,
 		ethWsClient,
 		txMgr,
@@ -236,6 +248,9 @@ func (config *BuildAllConfig) validate(logger logging.Logger) error {
 		logger.Error("BuildAllConfig.validate: Missing bls registry coordinator address")
 		return fmt.Errorf("BuildAllConfig.validate: Missing bls registry coordinator address")
 	}
+	if config.ServiceManagerAddress == "" {
+		logger.Info("BuildAllConfig.validate: Missing optional service manager address")
+	}
 	if config.OperatorStateRetrieverAddr == "" {
 		logger.Error("BuildAllConfig.validate: Missing bls operator state retriever address")
 		return fmt.Errorf("BuildAllConfig.validate: Missing bls operator state retriever address")

chainio/clients/elcontracts/types.go

@@ -9,6 +9,13 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+type RegistrationType uint8
+
+const (
+	RegistrationTypeNormal RegistrationType = 0
+	RegistrationTypeChurn  RegistrationType = 1
+)
+
 type OperatorSetStakes struct {
 	OperatorSet     allocationmanager.OperatorSet
 	Strategies      []common.Address

chainio/clients/elcontracts/writer.go

@@ -635,7 +635,7 @@ func (w *ChainWriter) RegisterForOperatorSets(
 		return nil, utils.WrapError("failed to get public key registration params", err)
 	}
 
-	data, err := abiEncodeRegistrationParams(request.Socket, *pubkeyRegParams)
+	data, err := AbiEncodeRegistrationParams(RegistrationTypeNormal, request.Socket, *pubkeyRegParams)
 	if err != nil {
 		return nil, utils.WrapError("failed to encode registration params", err)
 	}
@@ -851,7 +851,7 @@ func getPubkeyRegistrationParams(
 	ethClient bind.ContractBackend,
 	registryCoordinatorAddr, operatorAddress gethcommon.Address,
 	blsKeyPair *bls.KeyPair,
-) (*regcoord.IBLSApkRegistryPubkeyRegistrationParams, error) {
+) (*regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams, error) {
 	registryCoordinator, err := regcoord.NewContractRegistryCoordinator(registryCoordinatorAddr, ethClient)
 	if err != nil {
 		return nil, utils.WrapError("failed to create registry coordinator", err)
@@ -869,7 +869,7 @@ func getPubkeyRegistrationParams(
 	)
 	G1pubkeyBN254 := chainioutils.ConvertToBN254G1Point(blsKeyPair.GetPubKeyG1())
 	G2pubkeyBN254 := chainioutils.ConvertToBN254G2Point(blsKeyPair.GetPubKeyG2())
-	pubkeyRegParams := regcoord.IBLSApkRegistryPubkeyRegistrationParams{
+	pubkeyRegParams := regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams{
 		PubkeyRegistrationSignature: signedMsg,
 		PubkeyG1:                    G1pubkeyBN254,
 		PubkeyG2:                    G2pubkeyBN254,
@@ -878,11 +878,13 @@ func getPubkeyRegistrationParams(
 }
 
 // Returns the ABI encoding of the given registration params.
-func abiEncodeRegistrationParams(
+func AbiEncodeRegistrationParams(
+	registrationType RegistrationType,
 	socket string,
-	pubkeyRegistrationParams regcoord.IBLSApkRegistryPubkeyRegistrationParams,
+	pubkeyRegistrationParams regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams,
 ) ([]byte, error) {
 	registrationParamsType, err := abi.NewType("tuple", "", []abi.ArgumentMarshaling{
+		{Name: "RegistrationType", Type: "uint8"},
 		{Name: "Socket", Type: "string"},
 		{Name: "PubkeyRegParams", Type: "tuple", Components: []abi.ArgumentMarshaling{
 			{Name: "PubkeyRegistrationSignature", Type: "tuple", Components: []abi.ArgumentMarshaling{
@@ -904,9 +906,11 @@ func abiEncodeRegistrationParams(
 	}
 
 	registrationParams := struct {
-		Socket          string
-		PubkeyRegParams regcoord.IBLSApkRegistryPubkeyRegistrationParams
+		RegistrationType RegistrationType
+		Socket           string
+		PubkeyRegParams  regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams
 	}{
+		registrationType,
 		socket,
 		pubkeyRegistrationParams,
 	}