Merge branch 'dev' into test/invalid-input-reader

Makefile

@@ -19,7 +19,7 @@ mocks: ## generates mocks
 
 .PHONY: tests
 tests: ## runs all tests
-	go test -race ./... -timeout=4m
+	go test -race ./... -timeout=5m
 
 .PHONY: tests-cover
 tests-cover: ## run all tests with test coverge

chainio/clients/avsregistry/bindings.go

@@ -38,91 +38,6 @@ type ContractBindings struct {
 	OperatorStateRetriever *opstateretriever.ContractOperatorStateRetriever
 }
 
-// NewAVSRegistryContractBindings creates a new instance of ContractBindings
-// Deprecated: Use NewBindingsFromConfig instead
-func NewAVSRegistryContractBindings(
-	registryCoordinatorAddr gethcommon.Address,
-	operatorStateRetrieverAddr gethcommon.Address,
-	ethclient eth.HttpBackend,
-	logger logging.Logger,
-) (*ContractBindings, error) {
-	contractBlsRegistryCoordinator, err := regcoordinator.NewContractRegistryCoordinator(
-		registryCoordinatorAddr,
-		ethclient,
-	)
-	if err != nil {
-		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,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch ServiceManager contract", err)
-	}
-
-	stakeregistryAddr, err := contractBlsRegistryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StakeRegistry address", err)
-	}
-	contractStakeRegistry, err := stakeregistry.NewContractStakeRegistry(
-		stakeregistryAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch StakeRegistry contract", err)
-	}
-
-	blsApkRegistryAddr, err := contractBlsRegistryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch BLSPubkeyRegistry address", err)
-	}
-	contractBlsApkRegistry, err := blsapkregistry.NewContractBLSApkRegistry(
-		blsApkRegistryAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch BLSPubkeyRegistry contract", err)
-	}
-
-	indexRegistryAddr, err := contractBlsRegistryCoordinator.IndexRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch IndexRegistry address", err)
-	}
-	contractIndexRegistry, err := indexregistry.NewContractIndexRegistry(indexRegistryAddr, ethclient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch IndexRegistry contract", err)
-	}
-
-	contractOperatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethclient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to fetch OperatorStateRetriever contract", err)
-	}
-
-	return &ContractBindings{
-		ServiceManagerAddr:         serviceManagerAddr,
-		RegistryCoordinatorAddr:    registryCoordinatorAddr,
-		StakeRegistryAddr:          stakeregistryAddr,
-		BlsApkRegistryAddr:         blsApkRegistryAddr,
-		IndexRegistryAddr:          indexRegistryAddr,
-		OperatorStateRetrieverAddr: operatorStateRetrieverAddr,
-		ServiceManager:             contractServiceManager,
-		RegistryCoordinator:        contractBlsRegistryCoordinator,
-		StakeRegistry:              contractStakeRegistry,
-		BlsApkRegistry:             contractBlsApkRegistry,
-		IndexRegistry:              contractIndexRegistry,
-		OperatorStateRetriever:     contractOperatorStateRetriever,
-	}, nil
-}
-
 // NewBindingsFromConfig creates a new instance of ContractBindings
 func NewBindingsFromConfig(
 	cfg Config,

chainio/clients/avsregistry/reader.go

@@ -84,48 +84,6 @@ func NewReaderFromConfig(
 	), nil
 }
 
-// BuildAvsRegistryChainReader creates a new ChainReader
-// Deprecated: Use NewReaderFromConfig instead
-func BuildAvsRegistryChainReader(
-	registryCoordinatorAddr common.Address,
-	operatorStateRetrieverAddr common.Address,
-	ethClient eth.HttpBackend,
-	logger logging.Logger,
-) (*ChainReader, error) {
-	contractRegistryCoordinator, err := regcoord.NewContractRegistryCoordinator(registryCoordinatorAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractRegistryCoordinator", err)
-	}
-	blsApkRegistryAddr, err := contractRegistryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get blsApkRegistryAddr", err)
-	}
-	stakeRegistryAddr, err := contractRegistryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get stakeRegistryAddr", err)
-	}
-	contractStakeRegistry, err := stakeregistry.NewContractStakeRegistry(stakeRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractStakeRegistry", err)
-	}
-	contractOperatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethClient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create contractOperatorStateRetriever", err)
-	}
-	return NewChainReader(
-		registryCoordinatorAddr,
-		blsApkRegistryAddr,
-		contractRegistryCoordinator,
-		contractOperatorStateRetriever,
-		contractStakeRegistry,
-		logger,
-		ethClient,
-	), nil
-}
-
 func (r *ChainReader) GetQuorumCount(opts *bind.CallOpts) (uint8, error) {
 	if r.registryCoordinator == nil {
 		return 0, errors.New("RegistryCoordinator contract not provided")

chainio/clients/avsregistry/subscriber.go

@@ -2,7 +2,6 @@ package avsregistry
 
 import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/event"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
@@ -34,28 +33,6 @@ func NewChainSubscriber(
 	}
 }
 
-// BuildAvsRegistryChainSubscriber creates a new instance of ChainSubscriber
-// Deprecated: Use NewSubscriberFromConfig instead
-func BuildAvsRegistryChainSubscriber(
-	regCoordAddr common.Address,
-	ethWsClient eth.WsBackend,
-	logger logging.Logger,
-) (*ChainSubscriber, error) {
-	regCoord, err := regcoord.NewContractRegistryCoordinator(regCoordAddr, ethWsClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create RegistryCoordinator contract", err)
-	}
-	blsApkRegAddr, err := regCoord.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get BLSApkRegistry address from RegistryCoordinator", err)
-	}
-	blsApkReg, err := blsapkreg.NewContractBLSApkRegistry(blsApkRegAddr, ethWsClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create BLSApkRegistry contract", err)
-	}
-	return NewChainSubscriber(regCoord, blsApkReg, logger), nil
-}
-
 // NewSubscriberFromConfig creates a new instance of ChainSubscriber
 // A websocket ETH Client must be provided
 func NewSubscriberFromConfig(

chainio/clients/avsregistry/writer.go

@@ -19,12 +19,10 @@ import (
 	blsapkregistry "github.com/Layr-Labs/eigensdk-go/contracts/bindings/BLSApkRegistry"
 	opstateretriever "github.com/Layr-Labs/eigensdk-go/contracts/bindings/OperatorStateRetriever"
 	regcoord "github.com/Layr-Labs/eigensdk-go/contracts/bindings/RegistryCoordinator"
-	smbase "github.com/Layr-Labs/eigensdk-go/contracts/bindings/ServiceManagerBase"
 	stakeregistry "github.com/Layr-Labs/eigensdk-go/contracts/bindings/StakeRegistry"
 	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/types"
-	"github.com/Layr-Labs/eigensdk-go/utils"
 )
 
 type eLReader interface {
@@ -75,75 +73,6 @@ func NewChainWriter(
 	}
 }
 
-// BuildAvsRegistryChainWriter creates a new ChainWriter instance from the provided contract addresses
-// Deprecated: Use NewWriterFromConfig instead
-func BuildAvsRegistryChainWriter(
-	registryCoordinatorAddr gethcommon.Address,
-	operatorStateRetrieverAddr gethcommon.Address,
-	logger logging.Logger,
-	ethClient eth.HttpBackend,
-	txMgr txmgr.TxManager,
-) (*ChainWriter, error) {
-	registryCoordinator, err := regcoord.NewContractRegistryCoordinator(registryCoordinatorAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create RegistryCoordinator contract", err)
-	}
-	operatorStateRetriever, err := opstateretriever.NewContractOperatorStateRetriever(
-		operatorStateRetrieverAddr,
-		ethClient,
-	)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create OperatorStateRetriever contract", err)
-	}
-	serviceManagerAddr, err := registryCoordinator.ServiceManager(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get ServiceManager address", err)
-	}
-	serviceManager, err := smbase.NewContractServiceManagerBase(serviceManagerAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create ServiceManager contract", err)
-	}
-	blsApkRegistryAddr, err := registryCoordinator.BlsApkRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get BLSApkRegistry address", err)
-	}
-	blsApkRegistry, err := blsapkregistry.NewContractBLSApkRegistry(blsApkRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create BLSApkRegistry contract", err)
-	}
-	stakeRegistryAddr, err := registryCoordinator.StakeRegistry(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get StakeRegistry address", err)
-	}
-	stakeRegistry, err := stakeregistry.NewContractStakeRegistry(stakeRegistryAddr, ethClient)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create StakeRegistry contract", err)
-	}
-	delegationManagerAddr, err := stakeRegistry.Delegation(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get DelegationManager address", err)
-	}
-	avsDirectoryAddr, err := serviceManager.AvsDirectory(&bind.CallOpts{})
-	if err != nil {
-		return nil, utils.WrapError("Failed to get AvsDirectory address", err)
-	}
-	elReader, err := elcontracts.BuildELChainReader(delegationManagerAddr, avsDirectoryAddr, ethClient, logger)
-	if err != nil {
-		return nil, utils.WrapError("Failed to create ELChainReader", err)
-	}
-	return NewChainWriter(
-		serviceManagerAddr,
-		registryCoordinator,
-		operatorStateRetriever,
-		stakeRegistry,
-		blsApkRegistry,
-		elReader,
-		logger,
-		ethClient,
-		txMgr,
-	), nil
-}
-
 // NewWriterFromConfig creates a new ChainWriter from the provided config
 func NewWriterFromConfig(
 	cfg Config,

chainio/clients/avsregistry/writer_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Layr-Labs/eigensdk-go/types"
 	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -72,3 +73,37 @@ func TestWriterMethods(t *testing.T) {
 		require.NotNil(t, receipt)
 	})
 }
+
+// Compliance test for BLS signature
+func TestBlsSignature(t *testing.T) {
+	// read input from JSON if available, otherwise use default values
+	// Data taken from
+	// https://github.com/Layr-Labs/eigensdk-compliance/blob/429459572302d9fd42c1184b7257703460ba09ca/data_files/bls_signature.json
+	var defaultInput = struct {
+		Message    string `json:"message"`
+		BlsPrivKey string `json:"bls_priv_key"`
+	}{
+		Message:    "Hello, world!Hello, world!123456",
+		BlsPrivKey: "12248929636257230549931416853095037629726205319386239410403476017439825112537",
+	}
+
+	testData := testutils.NewTestData(defaultInput)
+	// The message to sign
+	messageArray := []byte(testData.Input.Message)
+
+	var messageArray32 [32]byte
+	copy(messageArray32[:], messageArray)
+
+	// The private key as a string
+	privKey, _ := bls.NewPrivateKey(testData.Input.BlsPrivKey)
+	keyPair := bls.NewKeyPair(privKey)
+
+	sig := keyPair.SignMessage(messageArray32)
+
+	x := sig.G1Affine.X.String()
+	y := sig.G1Affine.Y.String()
+
+	// Values taken from previous run of this test
+	assert.Equal(t, x, "15790168376429033610067099039091292283117017641532256477437243974517959682102")
+	assert.Equal(t, y, "4960450323239587206117776989095741074887370703941588742100855592356200866613")
+}