authzCustomBuilder = authz.NewBuilderForService(authz.Custom, lb.push, lb.node, useFilterState, policySvc)
	}

	var filters []*listener.Filter
	wasm := lb.push.WasmPluginsByListenerInfo(lb.node, model.WasmPluginListenerInfo{
		Port:    port,
		Class:   class,
		Service: policySvc,
	}, model.WasmPluginTypeNetwork)

	reqIDExtensionCtx := configureTracing(lb.push, lb.node, connectionManager, httpOpts.class, httpOpts.policySvc)

	filters := []*hcm.HttpFilter{}
	if !httpOpts.isWaypoint {
		wasm := lb.push.WasmPluginsByListenerInfo(lb.node, model.WasmPluginListenerInfo{
			Port:  httpOpts.port,
			Class: httpOpts.class,
		}, model.WasmPluginTypeHTTP)

	}

	// TODO: consider dedicated listener class for waypoint filters
	cls := istionetworking.ListenerClassSidecarInbound
	wasm := lb.push.WasmPluginsByListenerInfo(lb.node, model.WasmPluginListenerInfo{
		Class:   cls,
		Service: svc,
	}, model.WasmPluginTypeHTTP)
	// TODO: how to deal with ext-authz? It will be in the ordering twice

			if wsm.Name == n.Name {
				res = append(res, wsm)
				break
			}
		}
	}
	return res
}

// WasmPluginsByListenerInfo return the WasmPluginWrappers which are matched with TrafficSelector in the given proxy.
func (ps *PushContext) WasmPluginsByListenerInfo(proxy *Proxy, info WasmPluginListenerInfo,
	pluginType WasmPluginType,
) map[extensions.PluginPhase][]*WasmPluginWrapper {
	if proxy == nil {

func (lb *ListenerBuilder) buildInboundNetworkFiltersForHTTP(cc inboundChainConfig) []*listener.Filter {
	// Add network level WASM filters if any configured.
	httpOpts := buildSidecarInboundHTTPOpts(lb, cc)
	wasm := lb.push.WasmPluginsByListenerInfo(lb.node, model.WasmPluginListenerInfo{
		Port:  httpOpts.port,
		Class: httpOpts.class,
	}, model.WasmPluginTypeNetwork)

	var filters []*listener.Filter

	proxyConfig *meshconfig.ProxyConfig,
	mergedGateway *model.MergedGateway,
	tlsHostsByPort map[uint32]map[string]string,
) {
	// Add network level WASM filters if any configured.
	wasm := builder.push.WasmPluginsByListenerInfo(builder.node, model.WasmPluginListenerInfo{
		Port:  opts.port,
		Class: istionetworking.ListenerClassGateway,
	}, model.WasmPluginTypeNetwork)
	if p.IsHTTP() {

		l.ListenerFiltersTimeout = builder.push.Mesh.ProtocolDetectionTimeout
	} else {
		// Otherwise, do not have a timeout at all
		l.ListenerFiltersTimeout = durationpb.New(0)
	}
	wasm := builder.push.WasmPluginsByListenerInfo(builder.node, model.WasmPluginListenerInfo{
		Port:  le.servicePort.Port,
		Class: istionetworking.ListenerClassSidecarOutbound,
	}, model.WasmPluginTypeNetwork)
	for _, opt := range le.chains {

	// Init a new push context
	pc := NewPushContext()
	pc.Mesh = m
	pc.initWasmPlugins(env)

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := pc.WasmPluginsByListenerInfo(tc.node, tc.listenerInfo, tc.pluginType)
			if !reflect.DeepEqual(tc.expectedExtensions, result) {
				t.Errorf("WasmPlugins did not match expectations\n\ngot: %v\n\nexpected: %v", result, tc.expectedExtensions)
			}