Merge branch 'dev' into test/add-failing-network-tests

chainio/clients/avsregistry/writer_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"testing"
 
+	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	chainioutils "github.com/Layr-Labs/eigensdk-go/chainio/utils"
 	"github.com/Layr-Labs/eigensdk-go/crypto/bls"
 	"github.com/Layr-Labs/eigensdk-go/testutils"
@@ -16,8 +17,23 @@ import (
 )
 
 func TestWriterMethods(t *testing.T) {
-	clients, _ := testclients.BuildTestClients(t)
-	chainWriter := clients.AvsRegistryChainWriter
+	testConfig := testutils.GetDefaultTestConfig()
+	anvilC, err := testutils.StartAnvilContainer(testConfig.AnvilStateFileName)
+	require.NoError(t, err)
+
+	anvilHttpEndpoint, err := anvilC.Endpoint(context.Background(), "http")
+	require.NoError(t, err)
+	contractAddrs := testutils.GetContractAddressesFromContractRegistry(anvilHttpEndpoint)
+
+	operatorPrivateKeyHex := testutils.ANVIL_FIRST_PRIVATE_KEY
+
+	config := avsregistry.Config{
+		RegistryCoordinatorAddress:    contractAddrs.RegistryCoordinator,
+		OperatorStateRetrieverAddress: contractAddrs.OperatorStateRetriever,
+	}
+
+	chainWriter, err := testclients.NewTestAvsRegistryWriterFromConfig(anvilHttpEndpoint, operatorPrivateKeyHex, config)
+	require.NoError(t, err)
 
 	keypair, err := bls.NewKeyPairFromString("0x01")
 	require.NoError(t, err)
@@ -28,6 +44,16 @@ func TestWriterMethods(t *testing.T) {
 
 	quorumNumbers := types.QuorumNums{0}
 
+	t.Run("update socket without being registered", func(t *testing.T) {
+		receipt, err := chainWriter.UpdateSocket(
+			context.Background(),
+			types.Socket("102901920192019201902910291209"),
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
 	t.Run("register operator", func(t *testing.T) {
 		receipt, err := chainWriter.RegisterOperator(
 			context.Background(),
@@ -72,6 +98,118 @@ func TestWriterMethods(t *testing.T) {
 		require.NoError(t, err)
 		require.NotNil(t, receipt)
 	})
+
+	t.Run("update socket", func(t *testing.T) {
+		receipt, err := chainWriter.RegisterOperator(
+			context.Background(),
+			ecdsaPrivateKey,
+			keypair,
+			quorumNumbers,
+			"",
+			true,
+		)
+		require.NoError(t, err)
+		require.NotNil(t, receipt)
+
+		receipt, err = chainWriter.UpdateSocket(
+			context.Background(),
+			types.Socket(""),
+			true,
+		)
+		require.NoError(t, err)
+		require.NotNil(t, receipt)
+	})
+
+	// Error cases
+	t.Run("fail register operator cancelling context", func(t *testing.T) {
+		subCtx, cancelFn := context.WithCancel(context.Background())
+		cancelFn()
+		receipt, err := chainWriter.RegisterOperator(
+			subCtx,
+			ecdsaPrivateKey,
+			keypair,
+			quorumNumbers,
+			"",
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail update stake of operator subset cancelling context", func(t *testing.T) {
+		subCtx, cancelFn := context.WithCancel(context.Background())
+		cancelFn()
+		receipt, err := chainWriter.UpdateStakesOfOperatorSubsetForAllQuorums(
+			subCtx,
+			[]gethcommon.Address{addr},
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail update stake of entire operator set cancelling context", func(t *testing.T) {
+		subCtx, cancelFn := context.WithCancel(context.Background())
+		cancelFn()
+		receipt, err := chainWriter.UpdateStakesOfEntireOperatorSetForQuorums(
+			subCtx,
+			[][]gethcommon.Address{{addr}},
+			quorumNumbers,
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail update stake of entire operator set because of quorum length", func(t *testing.T) {
+		// Fails because operators per quorum length is distinct from quorum numbers
+		receipt, err := chainWriter.UpdateStakesOfEntireOperatorSetForQuorums(
+			context.Background(),
+			[][]gethcommon.Address{{addr, addr}},
+			quorumNumbers,
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail deregister operator cancelling context", func(t *testing.T) {
+		subCtx, cancelFn := context.WithCancel(context.Background())
+		cancelFn()
+		receipt, err := chainWriter.DeregisterOperator(
+			subCtx,
+			quorumNumbers,
+			chainioutils.ConvertToBN254G1Point(keypair.PubKey),
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail deregister operator because of operator not registered", func(t *testing.T) {
+		quorumNumbers := types.QuorumNums{}
+		receipt, err := chainWriter.DeregisterOperator(
+			context.Background(),
+			quorumNumbers,
+			chainioutils.ConvertToBN254G1Point(keypair.PubKey),
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
+
+	t.Run("fail update socket cancelling context", func(t *testing.T) {
+		subCtx, cancelFn := context.WithCancel(context.Background())
+
+		cancelFn()
+		receipt, err := chainWriter.UpdateSocket(
+			subCtx,
+			types.Socket(""),
+			true,
+		)
+		assert.Error(t, err)
+		assert.Nil(t, receipt)
+	})
 }
 
 // Compliance test for BLS signature

chainio/clients/elcontracts/reader.go

@@ -108,6 +108,9 @@ func (r *ChainReader) GetStakerShares(
 	ctx context.Context,
 	stakerAddress gethcommon.Address,
 ) ([]gethcommon.Address, []*big.Int, error) {
+	if r.delegationManager == nil {
+		return nil, nil, errors.New("DelegationManager contract not provided")
+	}
 	return r.delegationManager.GetDepositedShares(&bind.CallOpts{Context: ctx}, stakerAddress)
 }
 
@@ -117,6 +120,9 @@ func (r *ChainReader) GetDelegatedOperator(
 	stakerAddress gethcommon.Address,
 	blockNumber *big.Int,
 ) (gethcommon.Address, error) {
+	if r.delegationManager == nil {
+		return gethcommon.Address{}, errors.New("DelegationManager contract not provided")
+	}
 	return r.delegationManager.DelegatedTo(&bind.CallOpts{Context: ctx}, stakerAddress)
 }
 
@@ -433,6 +439,9 @@ func (r *ChainReader) GetNumOperatorSetsForOperator(
 	ctx context.Context,
 	operatorAddress gethcommon.Address,
 ) (*big.Int, error) {
+	if r.allocationManager == nil {
+		return nil, errors.New("AllocationManager contract not provided")
+	}
 	opSets, err := r.allocationManager.GetAllocatedSets(&bind.CallOpts{Context: ctx}, operatorAddress)
 	if err != nil {
 		return nil, err
@@ -446,6 +455,9 @@ func (r *ChainReader) GetOperatorSetsForOperator(
 	ctx context.Context,
 	operatorAddress gethcommon.Address,
 ) ([]allocationmanager.OperatorSet, error) {
+	if r.allocationManager == nil {
+		return nil, errors.New("AllocationManager contract not provided")
+	}
 	// TODO: we're fetching max int64 operatorSets here. What's the practical limit for timeout by RPC? do we need to
 	// paginate?
 	return r.allocationManager.GetAllocatedSets(&bind.CallOpts{Context: ctx}, operatorAddress)
@@ -459,6 +471,10 @@ func (r *ChainReader) IsOperatorRegisteredWithOperatorSet(
 ) (bool, error) {
 	if operatorSet.Id == 0 {
 		// this is an M2 AVS
+		if r.avsDirectory == nil {
+			return false, errors.New("AVSDirectory contract not provided")
+		}
+
 		status, err := r.avsDirectory.AvsOperatorStatus(&bind.CallOpts{Context: ctx}, operatorSet.Avs, operatorAddress)
 		// This call should not fail since it's a getter
 		if err != nil {
@@ -467,6 +483,9 @@ func (r *ChainReader) IsOperatorRegisteredWithOperatorSet(
 
 		return status == 1, nil
 	} else {
+		if r.allocationManager == nil {
+			return false, errors.New("AllocationManager contract not provided")
+		}
 		registeredOperatorSets, err := r.allocationManager.GetRegisteredSets(&bind.CallOpts{Context: ctx}, operatorAddress)
 		// This call should not fail since it's a getter
 		if err != nil {
@@ -491,6 +510,10 @@ func (r *ChainReader) GetOperatorsForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetMembers(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }
@@ -503,6 +526,10 @@ func (r *ChainReader) GetNumOperatorsForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetMemberCount(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }
@@ -516,6 +543,10 @@ func (r *ChainReader) GetStrategiesForOperatorSet(
 	if operatorSet.Id == 0 {
 		return nil, errLegacyAVSsNotSupported
 	} else {
+		if r.allocationManager == nil {
+			return nil, errors.New("AllocationManager contract not provided")
+		}
+
 		return r.allocationManager.GetStrategiesInOperatorSet(&bind.CallOpts{Context: ctx}, operatorSet)
 	}
 }