Adding CCIPCommitProvider to internal loop types (#496)

pkg/loop/internal/relayer/pluginprovider/ext/ccip/test/plugin_provider.go

@@ -19,4 +19,16 @@ var (
 		TransmitterID: "exec-testtransmitter",
 		PluginConfig:  []byte{133: 79},
 	}
+	CommitRelayArgs = types.RelayArgs{
+		ExternalJobID: uuid.MustParse("12348153-1234-5678-9012-fd0985d00000"),
+		JobID:         42,
+		ContractID:    "commit-testcontract",
+		New:           true,
+		RelayConfig:   []byte{1: 4, 36: 101},
+		ProviderType:  string(types.CCIPCommit),
+	}
+	CommitPluginArgs = types.PluginArgs{
+		TransmitterID: "commit-testtransmitter",
+		PluginConfig:  []byte{133: 79},
+	}
 )

pkg/loop/internal/relayer/relayer.go

@@ -372,6 +372,12 @@ func (r *relayerServer) NewPluginProvider(ctx context.Context, request *pb.NewPl
 			return nil, err
 		}
 		return &pb.NewPluginProviderReply{PluginProviderID: id}, nil
+	case string(types.CCIPCommit):
+		id, err := r.newCommitProvider(ctx, relayArgs, pluginArgs)
+		if err != nil {
+			return nil, err
+		}
+		return &pb.NewPluginProviderReply{PluginProviderID: id}, nil
 	case string(types.CCIPExecution):
 		id, err := r.newExecProvider(ctx, relayArgs, pluginArgs)
 		if err != nil {
@@ -487,6 +493,34 @@ func (r *relayerServer) newExecProvider(ctx context.Context, relayArgs types.Rel
 	return id, err
 }
 
+func (r *relayerServer) newCommitProvider(ctx context.Context, relayArgs types.RelayArgs, pluginArgs types.PluginArgs) (uint32, error) {
+	i, ok := r.impl.(looptypes.CCIPCommitProvider)
+	if !ok {
+		return 0, status.Error(codes.Unimplemented, fmt.Sprintf("ccip execution not supported by %T", r.impl))
+	}
+
+	provider, err := i.NewCommitProvider(ctx, relayArgs, pluginArgs)
+	if err != nil {
+		return 0, err
+	}
+	err = provider.Start(ctx)
+	if err != nil {
+		return 0, err
+	}
+	const name = "CCIPCommitProvider"
+	providerRes := net.Resource{Name: name, Closer: provider}
+
+	id, _, err := r.ServeNew(name, func(s *grpc.Server) {
+		ocr2.RegisterPluginProviderServices(s, provider)
+		ccip.RegisterCommitProviderServices(s, provider, r.BrokerExt)
+	}, providerRes)
+	if err != nil {
+		return 0, err
+	}
+
+	return id, err
+}
+
 func (r *relayerServer) GetChainStatus(ctx context.Context, request *pb.GetChainStatusRequest) (*pb.GetChainStatusReply, error) {
 	chain, err := r.impl.GetChainStatus(ctx)
 	if err != nil {

pkg/loop/internal/relayer/test/relayer.go

@@ -57,6 +57,7 @@ type staticPluginRelayerConfig struct {
 	agnosticProvider  testtypes.PluginProviderTester
 	mercuryProvider   mercurytest.MercuryProviderTester
 	executionProvider cciptest.ExecProviderTester
+	commitProvider    cciptest.CommitProviderTester
 	configProvider    ocr2test.ConfigProviderTester
 	// Note: add other Provider testers here when we implement them
 	// eg Functions, Automation, etc
@@ -175,15 +176,27 @@ func (s staticPluginRelayer) NewMercuryProvider(ctx context.Context, r types.Rel
 func (s staticPluginRelayer) NewExecutionProvider(ctx context.Context, r types.RelayArgs, p types.PluginArgs) (types.CCIPExecProvider, error) {
 	if s.StaticChecks {
 		if !equalRelayArgs(r, cciptest.ExecutionRelayArgs) {
-			return nil, fmt.Errorf("expected relay args:\n\t%v\nbut got:\n\t%v", mercurytest.RelayArgs, r)
+			return nil, fmt.Errorf("expected relay args:\n\t%v\nbut got:\n\t%v", cciptest.ExecutionRelayArgs, r)
 		}
 		if !reflect.DeepEqual(cciptest.ExecutionPluginArgs, p) {
-			return nil, fmt.Errorf("expected plugin args %v but got %v", mercurytest.PluginArgs, p)
+			return nil, fmt.Errorf("expected plugin args %v but got %v", cciptest.ExecutionPluginArgs, p)
 		}
 	}
 	return s.executionProvider, nil
 }
 
+func (s staticPluginRelayer) NewCommitProvider(ctx context.Context, r types.RelayArgs, p types.PluginArgs) (types.CCIPCommitProvider, error) {
+	if s.StaticChecks {
+		if !equalRelayArgs(r, cciptest.CommitRelayArgs) {
+			return nil, fmt.Errorf("expected relay args:\n\t%v\nbut got:\n\t%v", cciptest.CommitRelayArgs, r)
+		}
+		if !reflect.DeepEqual(cciptest.CommitPluginArgs, p) {
+			return nil, fmt.Errorf("expected plugin args %v but got %v", cciptest.CommitPluginArgs, p)
+		}
+	}
+	return s.commitProvider, nil
+}
+
 func (s staticPluginRelayer) NewLLOProvider(ctx context.Context, r types.RelayArgs, p types.PluginArgs) (types.LLOProvider, error) {
 	return nil, errors.New("not implemented")
 }

pkg/loop/internal/test/types/interfaces.go

@@ -94,6 +94,7 @@ type RelayerTester interface {
 	looptypes.MercuryProvider
 	looptypes.MedianProvider
 	looptypes.CCIPExecProvider
+	looptypes.CCIPCommitProvider
 
 	AssertEqualer[looptypes.Relayer]
 }

pkg/loop/internal/types/types.go

@@ -31,6 +31,10 @@ type CCIPExecProvider interface {
 	NewExecutionProvider(context.Context, types.RelayArgs, types.PluginArgs) (types.CCIPExecProvider, error)
 }
 
+type CCIPCommitProvider interface {
+	NewCommitProvider(context.Context, types.RelayArgs, types.PluginArgs) (types.CCIPCommitProvider, error)
+}
+
 // Relayer is like types.Relayer, but with a dynamic NewPluginProvider method.
 type Relayer interface {
 	types.ChainService