},
			inListener: &listener.Listener{
				Address: &core.Address{
					Address: &core.Address_SocketAddress{
						SocketAddress: &core.SocketAddress{Address: "1.1.1.1"},
					},
				},
				AdditionalAddresses: []*listener.AdditionalAddress{
					{
						Address: &core.Address{
							Address: &core.Address_SocketAddress{
								SocketAddress: &core.SocketAddress{Address: "1:1:1::1"},
							},
						},
					},

            {{ else }}
            "address": "{{ .wildcard }}",
            {{ end }}
            "port_value": {{ .envoy_prometheus_port }}
          }
        },
        {{- if .dual_stack }}
        "additionalAddresses": [
          {
            "address": {
              "socket_address": {
                "protocol": "TCP",
                {{- if .metrics_localhost_access_only }}

	var additionalAddresses []*listener.AdditionalAddress
	if len(extrAddresses) > 0 {
		for _, exbd := range extrAddresses {
			if exbd == "" {
				continue
			}
			extraAddress := &listener.AdditionalAddress{
				Address: BuildAddress(exbd, listenPort),
			}
			additionalAddresses = append(additionalAddresses, extraAddress)
		}
	}
	return additionalAddresses
}

			ListenerFilters: nil,
			UseOriginalDst:  nil,
		}
		// add extra addresses for the listener
		extrAddresses := si.Service.GetExtraAddressesForProxy(node)
		if len(extrAddresses) > 0 {
			ll.AdditionalAddresses = util.BuildAdditionalAddresses(extrAddresses, uint32(listenPort))
		}

		out = append(out, &discovery.Resource{
			Name:     ll.Name,
			Resource: protoconv.MessageToAny(ll),
		})
	}
	return out

		FilterChains:     filterChains,
		TrafficDirection: core.TrafficDirection_OUTBOUND,
	}
	// add extra addresses for the listener
	if features.EnableDualStack && len(actualWildcards) > 1 {
		ipTablesListener.AdditionalAddresses = util.BuildAdditionalAddresses(actualWildcards[1:], uint32(lb.push.Mesh.ProxyListenPort))
	} else if features.EnableAdditionalIpv4OutboundListenerForIpv6Only && (lb.node.GetIPMode() == model.IPv6) {

	vo := xdstest.ExtractListener(model.VirtualOutboundListenerName, listeners)
	if vo == nil {
		t.Fatalf("didn't find virtual outbound listener")
	}
	if vo.AdditionalAddresses == nil || len(vo.AdditionalAddresses) != 1 {
		t.Fatalf("expected additional ipv4 bind addresse")
	}

	}
	// add extra addresses for the listener
	if features.EnableDualStack && len(opts.extraBind) > 0 {
		res.AdditionalAddresses = util.BuildAdditionalAddresses(opts.extraBind, uint32(opts.port))
		// Ensure consistent transport protocol with main address
		for _, additionalAddress := range res.AdditionalAddresses {
			additionalAddress.GetAddress().GetSocketAddress().Protocol = transport.ToEnvoySocketProtocol()
		}
	}

		}
		if p.IsDualStack() {
			if len(listeners[0].AdditionalAddresses) != 1 {
				t.Fatalf("expected %d additional addresses, found %d", 1, len(listeners[0].AdditionalAddresses))
			}
			if listeners[0].AdditionalAddresses[0].GetAddress().GetSocketAddress().GetAddress() != wildcardIPv6 {
				t.Fatalf("expected additional address %s, found %s", wildcardIPv6, listeners[0].AdditionalAddresses[0].String())
			}
		}
	}
}

		TrafficDirection:                 core.TrafficDirection_INBOUND,
		ContinueOnListenerFiltersTimeout: true,
	}
	if features.EnableDualStack && len(addresses) > 1 {
		// add extra addresses for the listener
		l.AdditionalAddresses = util.BuildAdditionalAddresses(addresses[1:], tPort)
	}
	if lb.node.Metadata.InboundListenerExactBalance {
		l.ConnectionBalanceConfig = &listener.Listener_ConnectionBalanceConfig{