diff --git a/profiles/internal/naming/endpoint.go b/profiles/internal/naming/endpoint.go
index e38f3cf..74b1b2b 100644
--- a/profiles/internal/naming/endpoint.go
+++ b/profiles/internal/naming/endpoint.go
@@ -13,7 +13,6 @@
 	"strings"
 
 	"v.io/v23/naming"
-	"v.io/v23/rpc/version"
 )
 
 const (
@@ -33,14 +32,12 @@
 
 // Endpoint is a naming.Endpoint implementation used to convey RPC information.
 type Endpoint struct {
-	Protocol      string
-	Address       string
-	RID           naming.RoutingID
-	MinRPCVersion version.RPCVersion
-	MaxRPCVersion version.RPCVersion
-	Blessings     []string
-	IsMountTable  bool
-	IsLeaf        bool
+	Protocol     string
+	Address      string
+	RID          naming.RoutingID
+	Blessings    []string
+	IsMountTable bool
+	IsLeaf       bool
 }
 
 // NewEndpoint creates a new endpoint from a string as per naming.NewEndpoint
@@ -69,14 +66,6 @@
 	}
 
 	switch version {
-	case 1:
-		err = ep.parseV1(parts)
-	case 2:
-		err = ep.parseV2(parts)
-	case 3:
-		err = ep.parseV3(parts)
-	case 4:
-		err = ep.parseV4(parts)
 	case 5:
 		err = ep.parseV5(parts)
 	default:
@@ -99,46 +88,6 @@
 	return nil
 }
 
-func (ep *Endpoint) parseV1(parts []string) error {
-	if len(parts) != 4 {
-		return errInvalidEndpointString
-	}
-
-	ep.Protocol = parts[1]
-	if len(ep.Protocol) == 0 {
-		ep.Protocol = naming.UnknownProtocol
-	}
-
-	ep.Address = parts[2]
-	if len(ep.Address) == 0 {
-		ep.Address = net.JoinHostPort("", "0")
-	}
-
-	if err := ep.RID.FromString(parts[3]); err != nil {
-		return fmt.Errorf("invalid routing id: %v", err)
-	}
-
-	return nil
-}
-
-func parseRPCVersion(input string) (version.RPCVersion, error) {
-	if input == "" {
-		return version.UnknownRPCVersion, nil
-	}
-	v, err := strconv.ParseUint(input, 10, 32)
-	if err != nil {
-		err = fmt.Errorf("invalid RPC version: %s, %v", input, err)
-	}
-	return version.RPCVersion(v), err
-}
-
-func printRPCVersion(v version.RPCVersion) string {
-	if v == version.UnknownRPCVersion {
-		return ""
-	}
-	return strconv.FormatUint(uint64(v), 10)
-}
-
 func parseMountTableFlag(input string) (bool, bool, error) {
 	switch len(input) {
 	case 0:
@@ -158,59 +107,26 @@
 	return false, false, fmt.Errorf("flag is either missing or too long")
 }
 
-func (ep *Endpoint) parseV2(parts []string) error {
-	var err error
-	if len(parts) != 6 {
-		return errInvalidEndpointString
-	}
-	if err = ep.parseV1(parts[:4]); err != nil {
-		return err
-	}
-	if ep.MinRPCVersion, err = parseRPCVersion(parts[4]); err != nil {
-		return fmt.Errorf("invalid RPC version: %v", err)
-	}
-	if ep.MaxRPCVersion, err = parseRPCVersion(parts[5]); err != nil {
-		return fmt.Errorf("invalid RPC version: %v", err)
-	}
-	return nil
-}
-
-func (ep *Endpoint) parseV3(parts []string) error {
-	var err error
-	if len(parts) != 7 {
-		return errInvalidEndpointString
-	}
-	if err = ep.parseV2(parts[:6]); err != nil {
-		return err
-	}
-	if ep.IsMountTable, ep.IsLeaf, err = parseMountTableFlag(parts[6]); err != nil {
-		return fmt.Errorf("invalid mount table flag: %v", err)
-	}
-	return nil
-}
-
-func (ep *Endpoint) parseV4(parts []string) error {
-	if len(parts) < 7 {
-		return errInvalidEndpointString
-	}
-	if err := ep.parseV3(parts[:7]); err != nil {
-		return err
-	}
-	// Join the remaining and re-split.
-	if str := strings.Join(parts[7:], separator); len(str) > 0 {
-		ep.Blessings = strings.Split(str, blessingsSeparator)
-	}
-	return nil
-}
-
 func (ep *Endpoint) parseV5(parts []string) error {
 	if len(parts) < 5 {
 		return errInvalidEndpointString
 	}
-	var err error
-	if err = ep.parseV1(parts[:4]); err != nil {
-		return err
+
+	ep.Protocol = parts[1]
+	if len(ep.Protocol) == 0 {
+		ep.Protocol = naming.UnknownProtocol
 	}
+
+	ep.Address = parts[2]
+	if len(ep.Address) == 0 {
+		ep.Address = net.JoinHostPort("", "0")
+	}
+
+	if err := ep.RID.FromString(parts[3]); err != nil {
+		return fmt.Errorf("invalid routing id: %v", err)
+	}
+
+	var err error
 	if ep.IsMountTable, ep.IsLeaf, err = parseMountTableFlag(parts[4]); err != nil {
 		return fmt.Errorf("invalid mount table flag: %v", err)
 	}
@@ -218,8 +134,6 @@
 	if str := strings.Join(parts[5:], separator); len(str) > 0 {
 		ep.Blessings = strings.Split(str, blessingsSeparator)
 	}
-	ep.MinRPCVersion = version.DeprecatedRPCVersion
-	ep.MaxRPCVersion = version.DeprecatedRPCVersion
 	return nil
 }
 
@@ -238,34 +152,6 @@
 	switch version {
 	default:
 		return ep.VersionedString(defaultVersion)
-	case 1:
-		return fmt.Sprintf("@1@%s@%s@@", ep.Protocol, ep.Address)
-	case 2:
-		return fmt.Sprintf("@2@%s@%s@%s@%s@%s@@",
-			ep.Protocol, ep.Address, ep.RID,
-			printRPCVersion(ep.MinRPCVersion), printRPCVersion(ep.MaxRPCVersion))
-	case 3:
-		mt := "s"
-		if ep.IsMountTable {
-			mt = "m"
-		}
-		return fmt.Sprintf("@3@%s@%s@%s@%s@%s@%s@@",
-			ep.Protocol, ep.Address, ep.RID,
-			printRPCVersion(ep.MinRPCVersion), printRPCVersion(ep.MaxRPCVersion),
-			mt)
-	case 4:
-		mt := "s"
-		switch {
-		case ep.IsLeaf:
-			mt = "l"
-		case ep.IsMountTable:
-			mt = "m"
-		}
-		blessings := strings.Join(ep.Blessings, blessingsSeparator)
-		return fmt.Sprintf("@4@%s@%s@%s@%s@%s@%s@%s@@",
-			ep.Protocol, ep.Address, ep.RID,
-			printRPCVersion(ep.MinRPCVersion), printRPCVersion(ep.MaxRPCVersion),
-			mt, blessings)
 	case 5:
 		mt := "s"
 		switch {
@@ -282,12 +168,7 @@
 
 func (ep *Endpoint) String() string {
 	//nologcall
-	// Use version 4 if blessings are present, otherwise there is a loss of information.
-	v := defaultVersion
-	if len(ep.Blessings) > 0 && v < 4 {
-		v = 4
-	}
-	return ep.VersionedString(v)
+	return ep.VersionedString(defaultVersion)
 }
 
 func (ep *Endpoint) Name() string {
@@ -315,11 +196,6 @@
 	return ep.Blessings
 }
 
-func (ep *Endpoint) RPCVersionRange() version.RPCVersionRange {
-	//nologcall
-	return version.RPCVersionRange{Min: ep.MinRPCVersion, Max: ep.MaxRPCVersion}
-}
-
 type addr struct {
 	network, address string
 }
diff --git a/profiles/internal/naming/endpoint_test.go b/profiles/internal/naming/endpoint_test.go
index cd91fee..6c4fdb6 100644
--- a/profiles/internal/naming/endpoint_test.go
+++ b/profiles/internal/naming/endpoint_test.go
@@ -10,7 +10,6 @@
 	"testing"
 
 	"v.io/v23/naming"
-	"v.io/v23/rpc/version"
 )
 
 func TestEndpoint(t *testing.T) {
@@ -18,115 +17,53 @@
 	defer func() {
 		defaultVersion = defver
 	}()
-	v1 := &Endpoint{
+	v5a := &Endpoint{
 		Protocol:     naming.UnknownProtocol,
 		Address:      "batman.com:1234",
 		RID:          naming.FixedRoutingID(0xdabbad00),
 		IsMountTable: true,
 	}
-	v2 := &Endpoint{
-		Protocol:      naming.UnknownProtocol,
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xdabbad00),
-		MinRPCVersion: 1,
-		MaxRPCVersion: 10,
-		IsMountTable:  true,
-	}
-	v2hp := &Endpoint{
-		Protocol:      naming.UnknownProtocol,
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0x0),
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-		IsMountTable:  true,
-	}
-	v3s := &Endpoint{
-		Protocol:      naming.UnknownProtocol,
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0x0),
-		MinRPCVersion: 2,
-		MaxRPCVersion: 3,
-		IsMountTable:  false,
-	}
-	v3m := &Endpoint{
-		Protocol:      naming.UnknownProtocol,
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xdabbad00),
-		MinRPCVersion: 2,
-		MaxRPCVersion: 3,
-		IsMountTable:  true,
-	}
-	v3tcp := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0x0),
-		MinRPCVersion: 2,
-		MaxRPCVersion: 3,
-		IsMountTable:  false,
-	}
-	v3ws6 := &Endpoint{
-		Protocol:      "ws6",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0x0),
-		MinRPCVersion: 2,
-		MaxRPCVersion: 3,
-		IsMountTable:  false,
-	}
-	v4 := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xba77),
-		MinRPCVersion: 4,
-		MaxRPCVersion: 5,
-		IsMountTable:  true,
-		Blessings:     []string{"dev.v.io/foo@bar.com", "dev.v.io/bar@bar.com/delegate"},
-	}
-	v4b := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xba77),
-		MinRPCVersion: 4,
-		MaxRPCVersion: 5,
-		IsMountTable:  true,
-		// Blessings that look similar to other parts of the endpoint.
-		Blessings: []string{"@@", "@s", "@m"},
-	}
-	v5 := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xba77),
-		IsMountTable:  true,
-		Blessings:     []string{"dev.v.io/foo@bar.com", "dev.v.io/bar@bar.com/delegate"},
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-	}
 	v5b := &Endpoint{
+		Protocol:     naming.UnknownProtocol,
+		Address:      "batman.com:2345",
+		RID:          naming.FixedRoutingID(0xdabbad00),
+		IsMountTable: false,
+	}
+	v5c := &Endpoint{
+		Protocol:     "tcp",
+		Address:      "batman.com:2345",
+		RID:          naming.FixedRoutingID(0x0),
+		IsMountTable: false,
+	}
+	v5d := &Endpoint{
+		Protocol:     "ws6",
+		Address:      "batman.com:2345",
+		RID:          naming.FixedRoutingID(0x0),
+		IsMountTable: false,
+	}
+	v5e := &Endpoint{
+		Protocol:     "tcp",
+		Address:      "batman.com:2345",
+		RID:          naming.FixedRoutingID(0xba77),
+		IsMountTable: true,
+		Blessings:    []string{"dev.v.io/foo@bar.com", "dev.v.io/bar@bar.com/delegate"},
+	}
+	v5f := &Endpoint{
 		Protocol:     "tcp",
 		Address:      "batman.com:2345",
 		RID:          naming.FixedRoutingID(0xba77),
 		IsMountTable: true,
 		// Blessings that look similar to other parts of the endpoint.
-		Blessings:     []string{"@@", "@s", "@m"},
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-	}
-	v5c := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:2345",
-		RID:           naming.FixedRoutingID(0xba77),
-		IsMountTable:  false,
-		Blessings:     []string{"dev.v.io/foo@bar.com", "dev.v.io/bar@bar.com/delegate"},
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
+		Blessings: []string{"@@", "@s", "@m"},
 	}
 
 	testcasesA := []struct {
 		endpoint naming.Endpoint
 		address  string
 	}{
-		{v1, "batman.com:1234"},
-		{v2, "batman.com:2345"},
-		{v2hp, "batman.com:2345"},
+		{v5a, "batman.com:1234"},
+		{v5b, "batman.com:2345"},
+		{v5c, "batman.com:2345"},
 	}
 	for _, test := range testcasesA {
 		addr := test.endpoint.Addr()
@@ -135,73 +72,31 @@
 		}
 	}
 
-	// Test v3, v4, v5 endpoints.
+	// Test v5 endpoints.
 	testcasesC := []struct {
 		Endpoint naming.Endpoint
 		String   string
 		Version  int
 	}{
-		{v3s, "@3@@batman.com:2345@00000000000000000000000000000000@2@3@s@@", 3},
-		{v3m, "@3@@batman.com:2345@000000000000000000000000dabbad00@2@3@m@@", 3},
-		{v3tcp, "@3@tcp@batman.com:2345@00000000000000000000000000000000@2@3@s@@", 3},
-		{v3ws6, "@3@ws6@batman.com:2345@00000000000000000000000000000000@2@3@s@@", 3},
-		{v3s, "@4@@batman.com:2345@00000000000000000000000000000000@2@3@s@@@", 4},
-		{v4, "@4@tcp@batman.com:2345@0000000000000000000000000000ba77@4@5@m@dev.v.io/foo@bar.com,dev.v.io/bar@bar.com/delegate@@", 4},
-		{v4b, "@4@tcp@batman.com:2345@0000000000000000000000000000ba77@4@5@m@@@,@s,@m@@", 4},
-		{v5, "@5@tcp@batman.com:2345@0000000000000000000000000000ba77@m@dev.v.io/foo@bar.com,dev.v.io/bar@bar.com/delegate@@", 5},
-		{v5b, "@5@tcp@batman.com:2345@0000000000000000000000000000ba77@m@@@,@s,@m@@", 5},
-		{v5c, "@5@tcp@batman.com:2345@0000000000000000000000000000ba77@s@dev.v.io/foo@bar.com,dev.v.io/bar@bar.com/delegate@@", 5},
+		{v5a, "@5@@batman.com:1234@000000000000000000000000dabbad00@m@@@", 5},
+		{v5b, "@5@@batman.com:2345@000000000000000000000000dabbad00@s@@@", 5},
+		{v5c, "@5@tcp@batman.com:2345@00000000000000000000000000000000@s@@@", 5},
+		{v5d, "@5@ws6@batman.com:2345@00000000000000000000000000000000@s@@@", 5},
+		{v5e, "@5@tcp@batman.com:2345@0000000000000000000000000000ba77@m@dev.v.io/foo@bar.com,dev.v.io/bar@bar.com/delegate@@", 5},
+		{v5f, "@5@tcp@batman.com:2345@0000000000000000000000000000ba77@m@@@,@s,@m@@", 5},
 	}
 
-	for _, test := range testcasesC {
+	for i, test := range testcasesC {
 		if got, want := test.Endpoint.VersionedString(test.Version), test.String; got != want {
-			t.Errorf("Got %q want %q for endpoint (v%d): %#v", got, want, test.Version, test.Endpoint)
+			t.Errorf("Test %d: Got %q want %q for endpoint (v%d): %#v", i, got, want, test.Version, test.Endpoint)
 		}
 		ep, err := NewEndpoint(test.String)
 		if err != nil {
-			t.Errorf("Endpoint(%q) failed with %v", test.String, err)
+			t.Errorf("Test %d: Endpoint(%q) failed with %v", i, test.String, err)
 			continue
 		}
 		if !reflect.DeepEqual(ep, test.Endpoint) {
-			t.Errorf("Got endpoint %#v, want %#v for string %q", ep, test.Endpoint, test.String)
-		}
-	}
-
-	// Make sure we can continue to parse and create v2 endpoints.
-	defaultVersion = 2
-	testcasesB := []struct {
-		Endpoint naming.Endpoint
-		String   string
-		Input    string
-		min, max version.RPCVersion
-		servesMT bool
-	}{
-		{v1, "@2@@batman.com:1234@000000000000000000000000dabbad00@@@@", "", version.UnknownRPCVersion, version.UnknownRPCVersion, true},
-		{v2, "@2@@batman.com:2345@000000000000000000000000dabbad00@1@10@@", "", 1, 10, true},
-		{v2hp, "@2@@batman.com:2345@00000000000000000000000000000000@1@1@@", "batman.com:2345", 2, 3, true},
-	}
-
-	for _, test := range testcasesB {
-		if got, want := test.Endpoint.String(), test.String; got != want {
-			t.Errorf("Got %q want %q for endpoint %T = %#v", got, want, test.Endpoint, test.Endpoint)
-		}
-		str := test.Input
-		var ep naming.Endpoint
-		var err error
-		if str == "" {
-			str = test.String
-			ep, err = NewEndpoint(str)
-		} else {
-			ep, err = NewEndpoint(naming.FormatEndpoint(naming.UnknownProtocol, str,
-				version.RPCVersionRange{test.min, test.max},
-				naming.ServesMountTable(test.servesMT)))
-		}
-		if err != nil {
-			t.Errorf("Endpoint(%q) failed with %v", str, err)
-			continue
-		}
-		if !reflect.DeepEqual(ep, test.Endpoint) {
-			t.Errorf("Got endpoint %T = %#v, want %T = %#v for string %q", ep, ep, test.Endpoint, test.Endpoint, str)
+			t.Errorf("Test %d: Got endpoint %#v, want %#v for string %q", i, ep, test.Endpoint, test.String)
 		}
 	}
 }
@@ -211,22 +106,6 @@
 	err           error
 }
 
-func TestEndpointDefaults(t *testing.T) {
-	testcases := []endpointTest{
-		{"@1@tcp@batman@@@", "@5@tcp@batman@00000000000000000000000000000000@m@@@", nil},
-		{"@2@tcp@robin@@@@@", "@5@tcp@robin@00000000000000000000000000000000@m@@@", nil},
-		{"@1@@@@@", "@5@@:0@00000000000000000000000000000000@m@@@", nil},
-		{"@2@@@@@@@", "@5@@:0@00000000000000000000000000000000@m@@@", nil},
-		{"@1@tcp@batman:12@@@", "@5@tcp@batman:12@00000000000000000000000000000000@m@@@", nil},
-		{"@2@tcp@foo:12@@9@@@", "@5@tcp@foo:12@00000000000000000000000000000000@m@@@", nil},
-		{"@2@tcp@foo:12@@@4@@", "@5@tcp@foo:12@00000000000000000000000000000000@m@@@", nil},
-		{"@2@tcp@foo:12@@2@4@@", "@5@tcp@foo:12@00000000000000000000000000000000@m@@@", nil},
-		{"@3@@host:11@@@@m@@", "@5@@host:11@00000000000000000000000000000000@m@@@", nil},
-		{"@3@@host:12@@@@@@", "@5@@host:12@00000000000000000000000000000000@m@@@", nil},
-	}
-	runEndpointTests(t, testcases)
-}
-
 func runEndpointTests(t *testing.T, testcases []endpointTest) {
 	for _, test := range testcases {
 		ep, err := NewEndpoint(test.input)
@@ -252,39 +131,32 @@
 	defer func() {
 		defaultVersion = defver
 	}()
-	defaultVersion = 4
 	testcases := []endpointTest{
-		{"localhost:10", "@4@@localhost:10@00000000000000000000000000000000@@@m@@@", nil},
-		{"localhost:", "@4@@localhost:@00000000000000000000000000000000@@@m@@@", nil},
+		{"localhost:10", "@5@@localhost:10@00000000000000000000000000000000@m@@@", nil},
+		{"localhost:", "@5@@localhost:@00000000000000000000000000000000@m@@@", nil},
 		{"localhost", "", errInvalidEndpointString},
-		{"(dev.v.io/service/mounttabled)@ns.dev.v.io:8101", "@4@@ns.dev.v.io:8101@00000000000000000000000000000000@@@m@dev.v.io/service/mounttabled@@", nil},
-		{"(dev.v.io/users/foo@bar.com)@ns.dev.v.io:8101", "@4@@ns.dev.v.io:8101@00000000000000000000000000000000@@@m@dev.v.io/users/foo@bar.com@@", nil},
-		{"(@1@tcp)@ns.dev.v.io:8101", "@4@@ns.dev.v.io:8101@00000000000000000000000000000000@@@m@@1@tcp@@", nil},
+		{"(dev.v.io/service/mounttabled)@ns.dev.v.io:8101", "@5@@ns.dev.v.io:8101@00000000000000000000000000000000@m@dev.v.io/service/mounttabled@@", nil},
+		{"(dev.v.io/users/foo@bar.com)@ns.dev.v.io:8101", "@5@@ns.dev.v.io:8101@00000000000000000000000000000000@m@dev.v.io/users/foo@bar.com@@", nil},
+		{"(@1@tcp)@ns.dev.v.io:8101", "@5@@ns.dev.v.io:8101@00000000000000000000000000000000@m@@1@tcp@@", nil},
 	}
 	runEndpointTests(t, testcases)
 }
 
 func TestParseHostPort(t *testing.T) {
 	dns := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "batman.com:4444",
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-		IsMountTable:  true,
+		Protocol:     "tcp",
+		Address:      "batman.com:4444",
+		IsMountTable: true,
 	}
 	ipv4 := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "192.168.1.1:4444",
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-		IsMountTable:  true,
+		Protocol:     "tcp",
+		Address:      "192.168.1.1:4444",
+		IsMountTable: true,
 	}
 	ipv6 := &Endpoint{
-		Protocol:      "tcp",
-		Address:       "[01:02::]:4444",
-		MinRPCVersion: version.DeprecatedRPCVersion,
-		MaxRPCVersion: version.DeprecatedRPCVersion,
-		IsMountTable:  true,
+		Protocol:     "tcp",
+		Address:      "[01:02::]:4444",
+		IsMountTable: true,
 	}
 	testcases := []struct {
 		Endpoint   naming.Endpoint
diff --git a/profiles/internal/rpc/client.go b/profiles/internal/rpc/client.go
index f963e1d..dec6ba3 100644
--- a/profiles/internal/rpc/client.go
+++ b/profiles/internal/rpc/client.go
@@ -31,7 +31,6 @@
 	inaming "v.io/x/ref/profiles/internal/naming"
 	"v.io/x/ref/profiles/internal/rpc/stream"
 	"v.io/x/ref/profiles/internal/rpc/stream/vc"
-	"v.io/x/ref/profiles/internal/rpc/version"
 )
 
 const pkgPath = "v.io/x/ref/profiles/internal/rpc"
@@ -389,10 +388,6 @@
 		status.serverErr = suberr(verror.New(errInvalidEndpoint, ctx))
 		return
 	}
-	if err = version.CheckCompatibility(ep); err != nil {
-		status.serverErr = suberr(verror.New(errIncompatibleEndpoint, ctx))
-		return
-	}
 	if status.flow, status.serverErr = c.createFlow(ctx, principal, ep, append(vcOpts, &vc.ServerAuthorizer{Suffix: status.suffix, Method: method, Policy: auth})); status.serverErr != nil {
 		status.serverErr.Name = suberrName(server, name, method)
 		vlog.VI(2).Infof("rpc: Failed to create Flow with %v: %v", server, status.serverErr.Err)
diff --git a/profiles/internal/rpc/sort_endpoints.go b/profiles/internal/rpc/sort_endpoints.go
index 57409e7..49db0bc 100644
--- a/profiles/internal/rpc/sort_endpoints.go
+++ b/profiles/internal/rpc/sort_endpoints.go
@@ -16,7 +16,6 @@
 
 	"v.io/x/lib/netstate"
 	inaming "v.io/x/ref/profiles/internal/naming"
-	"v.io/x/ref/profiles/internal/rpc/version"
 )
 
 var (
@@ -105,11 +104,6 @@
 			adderr(name, verror.New(errMalformedEndpoint, nil, err))
 			continue
 		}
-		if err = version.CheckCompatibility(ep); err != nil {
-			// TODO(cnicolaou): convert rpc/version to verror.
-			adderr(name, verror.New(errIncompatibleEndpointVersions, nil, err))
-			continue
-		}
 		rank, err := protocol2rank(ep.Addr().Network(), protoRanks)
 		if err != nil {
 			adderr(name, err)
diff --git a/profiles/internal/rpc/sort_internal_test.go b/profiles/internal/rpc/sort_internal_test.go
index 3cfe452..2d0d545 100644
--- a/profiles/internal/rpc/sort_internal_test.go
+++ b/profiles/internal/rpc/sort_internal_test.go
@@ -11,7 +11,6 @@
 	"testing"
 
 	"v.io/v23/naming"
-	inaming "v.io/x/ref/profiles/internal/naming"
 )
 
 func servers2names(servers []naming.MountedServer) []string {
@@ -27,23 +26,6 @@
 		t.Errorf("expected a different error: %v", err)
 	}
 
-	for _, a := range []string{"127.0.0.1", "127.0.0.2"} {
-		ep := inaming.Endpoint{
-			Protocol:      "tcp",
-			Address:       a,
-			MinRPCVersion: 100,
-			MaxRPCVersion: 200,
-		}
-		addr := ep.VersionedString(4)
-		name := naming.JoinAddressName(addr, "")
-		servers = append(servers, naming.MountedServer{Server: name})
-	}
-
-	_, err = filterAndOrderServers(servers, []string{"tcp"}, nil)
-	if err == nil || (!strings.HasPrefix(err.Error(), "failed to find any compatible servers:") && !strings.Contains(err.Error(), "No compatible RPC versions available")) {
-		t.Errorf("expected a different error to: %v", err)
-	}
-
 	for _, a := range []string{"127.0.0.3", "127.0.0.4"} {
 		name := naming.JoinAddressName(naming.FormatEndpoint("tcp", a), "")
 		servers = append(servers, naming.MountedServer{Server: name})
diff --git a/profiles/internal/rpc/stream/manager/manager.go b/profiles/internal/rpc/stream/manager/manager.go
index 4b9c4b8..371f86a 100644
--- a/profiles/internal/rpc/stream/manager/manager.go
+++ b/profiles/internal/rpc/stream/manager/manager.go
@@ -26,7 +26,6 @@
 	"v.io/x/ref/profiles/internal/rpc/stream/crypto"
 	"v.io/x/ref/profiles/internal/rpc/stream/vc"
 	"v.io/x/ref/profiles/internal/rpc/stream/vif"
-	"v.io/x/ref/profiles/internal/rpc/version"
 )
 
 const pkgPath = "v.io/x/ref/profiles/internal/rpc/stream/manager"
@@ -135,15 +134,9 @@
 		conn.Close()
 		return vf, nil
 	}
-	vRange := version.SupportedRange
-	if ep, ok := remote.(*inaming.Endpoint); ok {
-		epRange := &version.Range{Min: ep.MinRPCVersion, Max: ep.MaxRPCVersion}
-		if r, err := vRange.Intersect(epRange); err == nil {
-			vRange = r
-		}
-	}
+
 	opts = append([]stream.VCOpt{vc.StartTimeout{defaultStartTimeout}}, opts...)
-	vf, err := vif.InternalNewDialedVIF(conn, m.rid, principal, vRange, m.deleteVIF, opts...)
+	vf, err := vif.InternalNewDialedVIF(conn, m.rid, principal, nil, m.deleteVIF, opts...)
 	if err != nil {
 		conn.Close()
 		return nil, err
@@ -233,7 +226,12 @@
 	ln := newNetListener(m, netln, principal, blessings, opts)
 	m.listeners[ln] = true
 	m.muListeners.Unlock()
-	return ln, version.Endpoint(protocol, netln.Addr().String(), m.rid), nil
+	ep := &inaming.Endpoint{
+		Protocol: protocol,
+		Address:  netln.Addr().String(),
+		RID:      m.rid,
+	}
+	return ln, ep, nil
 }
 
 func (m *manager) remoteListen(proxy naming.Endpoint, principal security.Principal, listenerOpts []stream.ListenerOpt) (stream.Listener, *inaming.Endpoint, error) {
diff --git a/profiles/internal/rpc/stream/manager/manager_test.go b/profiles/internal/rpc/stream/manager/manager_test.go
index b8cc61c..e28f505 100644
--- a/profiles/internal/rpc/stream/manager/manager_test.go
+++ b/profiles/internal/rpc/stream/manager/manager_test.go
@@ -31,7 +31,6 @@
 	"v.io/x/ref/profiles/internal/rpc/stream"
 	"v.io/x/ref/profiles/internal/rpc/stream/vc"
 	"v.io/x/ref/profiles/internal/rpc/stream/vif"
-	"v.io/x/ref/profiles/internal/rpc/version"
 	"v.io/x/ref/test"
 	"v.io/x/ref/test/expect"
 	"v.io/x/ref/test/modules"
@@ -634,7 +633,11 @@
 	// the address encoded in the endpoint (e.g. "0.0.0.0:55324") is different
 	// from the address of the connection (e.g. "127.0.0.1:55324").
 	_, port, _ := net.SplitHostPort(ep.Addr().String())
-	nep := version.Endpoint(ep.Addr().Network(), net.JoinHostPort("", port), ep.RoutingID())
+	nep := &inaming.Endpoint{
+		Protocol: ep.Addr().Network(),
+		Address:  net.JoinHostPort("", port),
+		RID:      ep.RoutingID(),
+	}
 
 	// Dial multiple VCs
 	for i := 0; i < 2; i++ {
diff --git a/profiles/internal/rpc/stream/message/control.go b/profiles/internal/rpc/stream/message/control.go
index cb03ddc..6fdde05 100644
--- a/profiles/internal/rpc/stream/message/control.go
+++ b/profiles/internal/rpc/stream/message/control.go
@@ -37,13 +37,14 @@
 	writeTo(w io.Writer) error
 }
 
-// OpenVC is a Control implementation requesting the creation of a new virtual
-// circuit.
-type OpenVC struct {
-	VCI         id.VC
-	DstEndpoint naming.Endpoint
-	SrcEndpoint naming.Endpoint
-	Counters    Counters
+// SetupVC is a Control implementation containing information to setup a new
+// virtual circuit.
+type SetupVC struct {
+	VCI            id.VC
+	LocalEndpoint  naming.Endpoint // Endpoint of the sender (as seen by the sender), can be nil.
+	RemoteEndpoint naming.Endpoint // Endpoint of the receiver (as seen by the sender), can be nil.
+	Counters       Counters
+	Setup          Setup // Negotiate versioning and encryption.
 }
 
 // CloseVC is a Control implementation notifying the closure of an established
@@ -56,17 +57,6 @@
 	Error string
 }
 
-// SetupVC is a Control implementation containing information to setup a new
-// virtual circuit. This message is expected to replace OpenVC and allow for
-// the two ends of a VC to establish a protocol version.
-type SetupVC struct {
-	VCI            id.VC
-	LocalEndpoint  naming.Endpoint // Endpoint of the sender (as seen by the sender), can be nil.
-	RemoteEndpoint naming.Endpoint // Endpoint of the receiver (as seen by the sender), can be nil.
-	Counters       Counters
-	Setup          Setup // Negotiate versioning and encryption.
-}
-
 // AddReceiveBuffers is a Control implementation used by the sender of the
 // message to inform the other end of a virtual circuit that it is ready to
 // receive more bytes of data (specified per flow).
@@ -132,7 +122,7 @@
 type command uint8
 
 const (
-	openVCCommand            command = 0
+	deprecatedOpenVCCommand  command = 0
 	closeVCCommand           command = 1
 	addReceiveBuffersCommand command = 2
 	openFlowCommand          command = 3
@@ -144,8 +134,6 @@
 func writeControl(w io.Writer, m Control) error {
 	var command command
 	switch m.(type) {
-	case *OpenVC:
-		command = openVCCommand
 	case *CloseVC:
 		command = closeVCCommand
 	case *AddReceiveBuffers:
@@ -181,8 +169,6 @@
 	command := command(header)
 	var m Control
 	switch command {
-	case openVCCommand:
-		m = new(OpenVC)
 	case closeVCCommand:
 		m = new(CloseVC)
 	case addReceiveBuffersCommand:
@@ -204,47 +190,6 @@
 	return m, nil
 }
 
-func (m *OpenVC) writeTo(w io.Writer) (err error) {
-	if err = writeInt(w, m.VCI); err != nil {
-		return
-	}
-	// Note that when we send OpenVC we always use v4 endpoints because
-	// the server needs to get version information from them.
-	if err = writeString(w, m.DstEndpoint.VersionedString(4)); err != nil {
-		return
-	}
-	if err = writeString(w, m.SrcEndpoint.VersionedString(4)); err != nil {
-		return
-	}
-	if err = writeCounters(w, m.Counters); err != nil {
-		return
-	}
-	return nil
-}
-
-func (m *OpenVC) readFrom(r *bytes.Buffer) (err error) {
-	if err = readInt(r, &m.VCI); err != nil {
-		return
-	}
-	var ep string
-	if err = readString(r, &ep); err != nil {
-		return
-	}
-	if m.DstEndpoint, err = inaming.NewEndpoint(ep); err != nil {
-		return
-	}
-	if err = readString(r, &ep); err != nil {
-		return
-	}
-	if m.SrcEndpoint, err = inaming.NewEndpoint(ep); err != nil {
-		return
-	}
-	if m.Counters, err = readCounters(r); err != nil {
-		return
-	}
-	return nil
-}
-
 func (m *CloseVC) writeTo(w io.Writer) (err error) {
 	if err = writeInt(w, m.VCI); err != nil {
 		return
diff --git a/profiles/internal/rpc/stream/message/message_test.go b/profiles/internal/rpc/stream/message/message_test.go
index 8bb99c7..8a05efc 100644
--- a/profiles/internal/rpc/stream/message/message_test.go
+++ b/profiles/internal/rpc/stream/message/message_test.go
@@ -11,7 +11,6 @@
 	"testing"
 
 	"v.io/v23/naming"
-	"v.io/v23/rpc/version"
 	"v.io/x/ref/profiles/internal/lib/iobuf"
 	inaming "v.io/x/ref/profiles/internal/naming"
 	"v.io/x/ref/profiles/internal/rpc/stream/crypto"
@@ -70,35 +69,20 @@
 	counters := NewCounters()
 	counters.Add(12, 13, 10240)
 	tests := []Control{
-		&OpenVC{VCI: 2,
-			DstEndpoint: iversion.Endpoint("tcp", "batman.com:1990", naming.FixedRoutingID(0xba7)),
-			SrcEndpoint: iversion.Endpoint("tcp", "google.com:80", naming.FixedRoutingID(0xba6)),
-		},
-		&OpenVC{
-			VCI:         4,
-			DstEndpoint: iversion.Endpoint("tcp", "batman.com:1990", naming.FixedRoutingID(0xba7)),
-			SrcEndpoint: iversion.Endpoint("tcp", "google.com:80", naming.FixedRoutingID(0xba6)),
-			Counters:    counters,
-		},
-
 		&CloseVC{VCI: 1},
 		&CloseVC{VCI: 2, Error: "some error"},
 
 		&SetupVC{
 			VCI: 1,
 			LocalEndpoint: &inaming.Endpoint{
-				Protocol:      "tcp",
-				Address:       "batman.com:1990",
-				RID:           naming.FixedRoutingID(0xba7),
-				MinRPCVersion: version.DeprecatedRPCVersion,
-				MaxRPCVersion: version.DeprecatedRPCVersion,
+				Protocol: "tcp",
+				Address:  "batman.com:1990",
+				RID:      naming.FixedRoutingID(0xba7),
 			},
 			RemoteEndpoint: &inaming.Endpoint{
-				Protocol:      "tcp",
-				Address:       "bugsbunny.com:1940",
-				RID:           naming.FixedRoutingID(0xbb),
-				MinRPCVersion: version.DeprecatedRPCVersion,
-				MaxRPCVersion: version.DeprecatedRPCVersion,
+				Protocol: "tcp",
+				Address:  "bugsbunny.com:1940",
+				RID:      naming.FixedRoutingID(0xbb),
 			},
 			Counters: counters,
 			Setup: Setup{
diff --git a/profiles/internal/rpc/stream/proxy/proxy.go b/profiles/internal/rpc/stream/proxy/proxy.go
index f74428b..3944e13 100644
--- a/profiles/internal/rpc/stream/proxy/proxy.go
+++ b/profiles/internal/rpc/stream/proxy/proxy.go
@@ -16,7 +16,6 @@
 	"v.io/v23/context"
 	"v.io/v23/naming"
 	"v.io/v23/rpc"
-	"v.io/v23/rpc/version"
 	"v.io/v23/security"
 	"v.io/v23/verror"
 	"v.io/v23/vom"
@@ -27,6 +26,7 @@
 	"v.io/x/ref/profiles/internal/lib/iobuf"
 	"v.io/x/ref/profiles/internal/lib/publisher"
 	"v.io/x/ref/profiles/internal/lib/upcqueue"
+	inaming "v.io/x/ref/profiles/internal/naming"
 	"v.io/x/ref/profiles/internal/rpc/stream"
 	"v.io/x/ref/profiles/internal/rpc/stream/crypto"
 	"v.io/x/ref/profiles/internal/rpc/stream/id"
@@ -51,7 +51,7 @@
 	// message visible to the user.
 	errNoRoutingTableEntry       = reg(".errNoRoutingTableEntry", "routing table has no entry for the VC")
 	errProcessVanished           = reg(".errProcessVanished", "remote process vanished")
-	errDuplicateOpenVC           = reg(".errDuplicateOpenVC", "duplicate OpenVC request")
+	errDuplicateSetupVC          = reg(".errDuplicateSetupVC", "duplicate SetupVC request")
 	errVomDecoder                = reg(".errVomDecoder", "failed to create vom decoder{:3}")
 	errVomEncoder                = reg(".errVomEncoder", "failed to create vom encoder{:3}")
 	errVomEncodeResponse         = reg(".errVomEncodeResponse", "failed to encode response from proxy{:3}")
@@ -345,13 +345,13 @@
 		response.Error = verror.Convert(verror.ErrUnknown, nil, err)
 	} else {
 		defer p.servers.Remove(server)
-		ep, err := iversion.ProxiedEndpoint(server.VC.RemoteEndpoint().RoutingID(), p.endpoint())
-		if err != nil {
-			response.Error = verror.Convert(verror.ErrInternal, nil, err)
+		proxyEP := p.endpoint()
+		ep := &inaming.Endpoint{
+			Protocol: proxyEP.Protocol,
+			Address:  proxyEP.Address,
+			RID:      server.VC.RemoteEndpoint().RoutingID(),
 		}
-		if ep != nil {
-			response.Endpoint = ep.String()
-		}
+		response.Endpoint = ep.String()
 	}
 	enc, err := vom.NewEncoder(conn)
 	if err != nil {
@@ -409,8 +409,13 @@
 
 // Endpoint returns the endpoint of the proxy service.  By Dialing a VC to this
 // endpoint, processes can have their services exported through the proxy.
-func (p *Proxy) endpoint() naming.Endpoint {
-	ep := iversion.Endpoint(p.ln.Addr().Network(), p.pubAddress, p.rid)
+func (p *Proxy) endpoint() *inaming.Endpoint {
+
+	ep := &inaming.Endpoint{
+		Protocol: p.ln.Addr().Network(),
+		Address:  p.pubAddress,
+		RID:      p.rid,
+	}
 	if prncpl := p.principal; prncpl != nil {
 		for b, _ := range prncpl.BlessingsInfo(prncpl.BlessingStore().Default()) {
 			ep.Blessings = append(ep.Blessings, b)
@@ -577,7 +582,7 @@
 			if naming.Compare(dstrid, p.proxy.rid) || naming.Compare(dstrid, naming.NullRoutingID) {
 				// VC that terminates at the proxy.
 				// See protocol.vdl for details on the protocol between the server and the proxy.
-				vcObj := p.NewServerSetupVC(m)
+				vcObj := p.NewServerVC(m)
 				// route counters after creating the VC so counters to vc are not lost.
 				p.proxy.routeCounters(p, m.Counters)
 				if vcObj != nil {
@@ -654,44 +659,6 @@
 			d.Process.queue.Put(m)
 			p.proxy.routeCounters(p, counters)
 
-		case *message.OpenVC:
-			dstrid := m.DstEndpoint.RoutingID()
-			if naming.Compare(dstrid, p.proxy.rid) || naming.Compare(dstrid, naming.NullRoutingID) {
-				// VC that terminates at the proxy.
-				// See protocol.vdl for details on the protocol between the server and the proxy.
-				vcObj, vers := p.NewServerVC(m)
-				// route counters after creating the VC so counters to vc are not lost.
-				p.proxy.routeCounters(p, m.Counters)
-				if vcObj != nil {
-					server := &server{Process: p, VC: vcObj}
-					go p.proxy.runServer(server, vcObj.HandshakeAcceptedVC(vers, p.proxy.principal, p.proxy.blessings, nil))
-				}
-				break
-			}
-			dstprocess := p.proxy.servers.Process(dstrid)
-			if dstprocess == nil {
-				p.SendCloseVC(m.VCI, verror.New(stream.ErrProxy, nil, verror.New(errServerNotBeingProxied, nil, dstrid)))
-				p.proxy.routeCounters(p, m.Counters)
-				break
-			}
-			srcVCI := m.VCI
-			dstVCI := dstprocess.AllocVCI()
-			startRoutingVC(srcVCI, dstVCI, p, dstprocess)
-			// Forward the OpenVC message.
-			// Typically, an OpenVC message is accompanied with Counters for the new VC.
-			// Keep that in the forwarded message and route the remaining counters separately.
-			counters := m.Counters
-			m.Counters = message.NewCounters()
-			for cid, bytes := range counters {
-				if cid.VCI() == srcVCI {
-					m.Counters.Add(dstVCI, cid.Flow(), bytes)
-					delete(counters, cid)
-				}
-			}
-			m.VCI = dstVCI
-			dstprocess.queue.Put(m)
-			p.proxy.routeCounters(p, counters)
-
 		default:
 			processLog().Infof("Closing %v because of invalid message %T", p, m)
 			return
@@ -768,36 +735,11 @@
 	return p.servers[vci]
 }
 
-func (p *process) NewServerVC(m *message.OpenVC) (*vc.VC, version.RPCVersion) {
+func (p *process) NewServerVC(m *message.SetupVC) *vc.VC {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 	if vc := p.servers[m.VCI]; vc != nil {
-		vc.Close(verror.New(stream.ErrProxy, nil, verror.New(errDuplicateOpenVC, nil)))
-		return nil, version.UnknownRPCVersion
-	}
-	vers, err := iversion.CommonVersion(m.DstEndpoint, m.SrcEndpoint)
-	if err != nil {
-		p.SendCloseVC(m.VCI, verror.New(stream.ErrProxy, nil, verror.New(errIncompatibleVersions, nil, err)))
-		return nil, vers
-	}
-	vc := vc.InternalNew(vc.Params{
-		VCI:          m.VCI,
-		LocalEP:      m.DstEndpoint,
-		RemoteEP:     m.SrcEndpoint,
-		Pool:         p.pool,
-		ReserveBytes: message.HeaderSizeBytes,
-		Helper:       p,
-	})
-	p.servers[m.VCI] = vc
-	proxyLog().Infof("Registered VC %v from server on process %v", vc, p)
-	return vc, vers
-}
-
-func (p *process) NewServerSetupVC(m *message.SetupVC) *vc.VC {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	if vc := p.servers[m.VCI]; vc != nil {
-		vc.Close(verror.New(stream.ErrProxy, nil, verror.New(errDuplicateOpenVC, nil)))
+		vc.Close(verror.New(stream.ErrProxy, nil, verror.New(errDuplicateSetupVC, nil)))
 		return nil
 	}
 	vc := vc.InternalNew(vc.Params{
diff --git a/profiles/internal/rpc/stream/vc/vc.go b/profiles/internal/rpc/stream/vc/vc.go
index 8f4a5eb..5889cc6 100644
--- a/profiles/internal/rpc/stream/vc/vc.go
+++ b/profiles/internal/rpc/stream/vc/vc.go
@@ -475,92 +475,60 @@
 // from another goroutine.
 // TODO(mattr): vers can be removed as a parameter when we get rid of TLS and
 // the version is always obtained via the Setup call.
-func (vc *VC) HandshakeDialedVC(principal security.Principal, vers version.RPCVersion, sendKey func(*crypto.BoxKey) error, opts ...stream.VCOpt) error {
-	var remotePubKeyChan chan *crypto.BoxKey
-	if sendKey != nil {
-		remotePubKeyChan = make(chan *crypto.BoxKey, 1)
-		vc.mu.Lock()
-		vc.remotePubKeyChan = remotePubKeyChan
-		vc.mu.Unlock()
-	}
+func (vc *VC) HandshakeDialedVC(principal security.Principal, sendKey func(*crypto.BoxKey) error, opts ...stream.VCOpt) error {
+	remotePubKeyChan := make(chan *crypto.BoxKey, 1)
+	vc.mu.Lock()
+	vc.remotePubKeyChan = remotePubKeyChan
+	vc.mu.Unlock()
 
 	// principal = nil means that we are running in SecurityNone and we don't need
 	// to authenticate the VC.  We still need to negotiate versioning information,
 	// so we still set remotePubKeyChan and call sendKey, though we don't care about
 	// the resulting key.
 	if principal == nil {
-		if sendKey != nil {
-			if err := sendKey(nil); err != nil {
-				return err
-			}
-			// TODO(mattr): Error on some timeout so a non-responding server doesn't
-			// cause this to hang forever.
-			select {
-			case <-remotePubKeyChan:
-			case <-vc.closeCh:
-				return verror.New(stream.ErrNetwork, nil, verror.New(errClosedDuringHandshake, nil, vc.VCI))
-			}
+		if err := sendKey(nil); err != nil {
+			return err
+		}
+		// TODO(mattr): Error on some timeout so a non-responding server doesn't
+		// cause this to hang forever.
+		select {
+		case <-remotePubKeyChan:
+		case <-vc.closeCh:
+			return verror.New(stream.ErrNetwork, nil, verror.New(errClosedDuringHandshake, nil, vc.VCI))
 		}
 		return nil
 	}
 
-	var (
-		tlsSessionCache crypto.TLSClientSessionCache
-		auth            *ServerAuthorizer
-	)
+	var auth *ServerAuthorizer
 	for _, o := range opts {
 		switch v := o.(type) {
-		case crypto.TLSClientSessionCache:
-			tlsSessionCache = v
 		case *ServerAuthorizer:
 			auth = v
 		}
 	}
 
-	var crypter crypto.Crypter
-
-	if sendKey != nil {
-		exchange := func(pubKey *crypto.BoxKey) (*crypto.BoxKey, error) {
-			if err := sendKey(pubKey); err != nil {
-				return nil, err
-			}
-			// TODO(mattr): Error on some timeout so a non-responding server doesn't
-			// cause this to hang forever.
-			select {
-			case theirKey := <-remotePubKeyChan:
-				return theirKey, nil
-			case <-vc.closeCh:
-				return nil, verror.New(stream.ErrNetwork, nil, verror.New(errClosedDuringHandshake, nil, vc.VCI))
-			}
+	exchange := func(pubKey *crypto.BoxKey) (*crypto.BoxKey, error) {
+		if err := sendKey(pubKey); err != nil {
+			return nil, err
 		}
-		var err error
-		crypter, err = crypto.NewBoxCrypter(exchange, vc.pool)
-		if err != nil {
-			return vc.appendCloseReason(verror.New(stream.ErrSecurity, nil,
-				verror.New(errFailedToSetupEncryption, nil, err)))
-		}
-		// The version is set by FinishHandshakeDialedVC and exchange (called by
-		// NewBoxCrypter) will block until FinishHandshakeDialedVC is called, so we
-		// should look up the version now.
-		vers = vc.Version()
-	} else {
-		// Establish TLS
-		handshakeConn, err := vc.connectFID(HandshakeFlowID, systemFlowPriority)
-		if err != nil {
-			return vc.appendCloseReason(verror.New(stream.ErrSecurity, nil, verror.New(errFailedToCreateTLSFlow, nil, err)))
-		}
-		crypter, err = crypto.NewTLSClient(handshakeConn,
-			handshakeConn.LocalEndpoint(), handshakeConn.RemoteEndpoint(),
-			tlsSessionCache, vc.pool)
-		if err != nil {
-			// Assume that we don't trust the server if the TLS handshake fails for any
-			// reason other than EOF.
-			if err == io.EOF {
-				return vc.appendCloseReason(verror.New(stream.ErrNetwork, nil, verror.New(errFailedToSetupEncryption, nil, err)))
-			}
-			return vc.appendCloseReason(verror.New(stream.ErrNotTrusted, nil, verror.New(errFailedToSetupEncryption, nil, err)))
+		// TODO(mattr): Error on some timeout so a non-responding server doesn't
+		// cause this to hang forever.
+		select {
+		case theirKey := <-remotePubKeyChan:
+			return theirKey, nil
+		case <-vc.closeCh:
+			return nil, verror.New(stream.ErrNetwork, nil, verror.New(errClosedDuringHandshake, nil, vc.VCI))
 		}
 	}
+	crypter, err := crypto.NewBoxCrypter(exchange, vc.pool)
+	if err != nil {
+		return vc.appendCloseReason(verror.New(stream.ErrSecurity, nil,
+			verror.New(errFailedToSetupEncryption, nil, err)))
+	}
+	// The version is set by FinishHandshakeDialedVC and exchange (called by
+	// NewBoxCrypter) will block until FinishHandshakeDialedVC is called, so we
+	// should look up the version now.
+	vers := vc.Version()
 
 	// Authenticate (exchange identities)
 	// Unfortunately, handshakeConn cannot be used for the authentication protocol.
@@ -580,9 +548,6 @@
 		LocalEndpoint:  vc.localEP,
 		RemoteEndpoint: vc.remoteEP,
 	}
-	vc.mu.Lock()
-	vc.version = vers
-	vc.mu.Unlock()
 
 	rBlessings, lBlessings, rDischarges, err := AuthenticateAsClient(authConn, crypter, params, auth, vers)
 	if err != nil || len(rBlessings.ThirdPartyCaveats()) == 0 {
@@ -665,12 +630,9 @@
 	// using SetupVC.
 	vc.helper.AddReceiveBuffers(vc.VCI(), SharedFlowID, DefaultBytesBufferedPerFlow)
 
-	// principal = nil means that we are running in SecurityNone and we don't need
+	// principal == nil means that we are running in SecurityNone and we don't need
 	// to authenticate the VC.
 	if principal == nil {
-		if exchange == nil {
-			return finish(ln, nil)
-		}
 		go func() {
 			_, err = exchange(nil)
 			result <- HandshakeResult{ln, err}
@@ -690,34 +652,10 @@
 		vc.acceptHandshakeDone = make(chan struct{})
 		vc.mu.Unlock()
 
-		if exchange != nil {
-			crypter, err = crypto.NewBoxCrypter(exchange, vc.pool)
-			if err != nil {
-				sendErr(verror.New(stream.ErrSecurity, nil, verror.New(errFailedToSetupEncryption, nil, err)))
-				return
-			}
-		} else {
-			// TODO(ashankar): There should be a timeout on this Accept
-			// call.  Otherwise, a malicious (or incompetent) client can
-			// consume server resources by sending many OpenVC messages but
-			// not following up with the handshake protocol. Same holds for
-			// the identity exchange protocol.
-			handshakeConn, err := ln.Accept()
-			if err != nil {
-				sendErr(verror.New(stream.ErrNetwork, nil, verror.New(errTLSFlowNotAccepted, nil, err)))
-				return
-			}
-			if vc.findFlow(handshakeConn) != HandshakeFlowID {
-				// This should have been the handshake flow, but it isn't.  We can't establish
-				// TLS, so send an error back.
-				sendErr(verror.New(stream.ErrSecurity, nil, verror.New(errFailedToCreateTLSFlow, nil, err)))
-			}
-			// Establish TLS
-			crypter, err = crypto.NewTLSServer(handshakeConn, handshakeConn.LocalEndpoint(), handshakeConn.RemoteEndpoint(), vc.pool)
-			if err != nil {
-				sendErr(verror.New(stream.ErrSecurity, nil, verror.New(errFailedToSetupEncryption, nil, err)))
-				return
-			}
+		crypter, err = crypto.NewBoxCrypter(exchange, vc.pool)
+		if err != nil {
+			sendErr(verror.New(stream.ErrSecurity, nil, verror.New(errFailedToSetupEncryption, nil, err)))
+			return
 		}
 
 		// Authenticate (exchange identities)
@@ -854,9 +792,6 @@
 }
 
 func (vc *VC) connectSystemFlows() error {
-	if vc.Version() < version.RPCVersion8 {
-		return nil
-	}
 	conn, err := vc.connectFID(TypeFlowID, systemFlowPriority)
 	if err != nil {
 		return verror.New(stream.ErrSecurity, nil, verror.New(errFailedToCreateFlowForWireType, nil, err))
@@ -877,9 +812,6 @@
 }
 
 func (vc *VC) acceptSystemFlows(ln stream.Listener) error {
-	if vc.Version() < version.RPCVersion8 {
-		return nil
-	}
 	conn, err := ln.Accept()
 	if err != nil {
 		return verror.New(errFlowForWireTypeNotAccepted, nil, err)
diff --git a/profiles/internal/rpc/stream/vc/vc_test.go b/profiles/internal/rpc/stream/vc/vc_test.go
index 9908261..2fe9918 100644
--- a/profiles/internal/rpc/stream/vc/vc_test.go
+++ b/profiles/internal/rpc/stream/vc/vc_test.go
@@ -285,14 +285,6 @@
 }
 func TestConnect_SmallNoSecurity(t *testing.T) { testConnect_Small(t, LatestVersion, SecurityNone) }
 func TestConnect_Small(t *testing.T)           { testConnect_Small(t, LatestVersion, SecurityDefault) }
-func TestConnect_Small7NoSecurity(t *testing.T) {
-	testConnect_Small(t, version.RPCVersion7, SecurityNone)
-}
-func TestConnect_Small7(t *testing.T) { testConnect_Small(t, version.RPCVersion7, SecurityDefault) }
-func TestConnect_Small8NoSecurity(t *testing.T) {
-	testConnect_Small(t, version.RPCVersion8, SecurityNone)
-}
-func TestConnect_Small8(t *testing.T) { testConnect_Small(t, version.RPCVersion8, SecurityDefault) }
 
 func testConnect(t *testing.T, securityLevel options.SecurityLevel) {
 	h, vc, err := NewSimple(LatestVersion, securityLevel)
@@ -513,20 +505,19 @@
 
 	var clientExchanger func(*crypto.BoxKey) error
 	var serverExchanger func(*crypto.BoxKey) (*crypto.BoxKey, error)
-	if v >= version.RPCVersion9 {
-		server, client := make(chan *crypto.BoxKey, 1), make(chan *crypto.BoxKey, 1)
-		clientExchanger = func(pubKey *crypto.BoxKey) error {
-			client <- pubKey
-			return clientH.VC.FinishHandshakeDialedVC(v, <-server)
-		}
-		serverExchanger = func(pubKey *crypto.BoxKey) (*crypto.BoxKey, error) {
-			server <- pubKey
-			return <-client, nil
-		}
+
+	serverch, clientch := make(chan *crypto.BoxKey, 1), make(chan *crypto.BoxKey, 1)
+	clientExchanger = func(pubKey *crypto.BoxKey) error {
+		clientch <- pubKey
+		return clientH.VC.FinishHandshakeDialedVC(v, <-serverch)
+	}
+	serverExchanger = func(pubKey *crypto.BoxKey) (*crypto.BoxKey, error) {
+		serverch <- pubKey
+		return <-clientch, nil
 	}
 
 	c := serverH.VC.HandshakeAcceptedVC(v, server, bserver, serverExchanger, lopts...)
-	if err := clientH.VC.HandshakeDialedVC(client, v, clientExchanger, vcopts...); err != nil {
+	if err := clientH.VC.HandshakeDialedVC(client, clientExchanger, vcopts...); err != nil {
 		go func() { <-c }()
 		return nil, nil, err
 	}
diff --git a/profiles/internal/rpc/stream/vif/vif.go b/profiles/internal/rpc/stream/vif/vif.go
index 4298040..d20b63e 100644
--- a/profiles/internal/rpc/stream/vif/vif.go
+++ b/profiles/internal/rpc/stream/vif/vif.go
@@ -20,7 +20,6 @@
 
 	"v.io/v23/context"
 	"v.io/v23/naming"
-	"v.io/v23/rpc/version"
 	"v.io/v23/security"
 	"v.io/v23/verror"
 	"v.io/v23/vtrace"
@@ -32,6 +31,7 @@
 	"v.io/x/ref/profiles/internal/lib/pcqueue"
 	vsync "v.io/x/ref/profiles/internal/lib/sync"
 	"v.io/x/ref/profiles/internal/lib/upcqueue"
+	inaming "v.io/x/ref/profiles/internal/naming"
 	"v.io/x/ref/profiles/internal/rpc/stream"
 	"v.io/x/ref/profiles/internal/rpc/stream/crypto"
 	"v.io/x/ref/profiles/internal/rpc/stream/id"
@@ -316,51 +316,28 @@
 	counters := message.NewCounters()
 	counters.Add(vc.VCI(), sharedFlowID, defaultBytesBufferedPerFlow)
 
-	ver, err := vif.versions.CommonVersion(vif.localEP, remoteEP)
-
-	switch {
-	case verror.ErrorID(err) == iversion.ErrDeprecatedVersion.ID || ver >= version.RPCVersion9:
-		sendPublicKey := func(pubKey *crypto.BoxKey) error {
-			var options []message.SetupOption
-			if pubKey != nil {
-				options = []message.SetupOption{&message.NaclBox{PublicKey: *pubKey}}
-			}
-			err := vif.sendOnExpressQ(&message.SetupVC{
-				VCI:            vc.VCI(),
-				RemoteEndpoint: remoteEP,
-				LocalEndpoint:  vif.localEP,
-				Counters:       counters,
-				Setup: message.Setup{
-					Versions: *vif.versions,
-					Options:  options,
-				},
-			})
-			if err != nil {
-				err = verror.New(stream.ErrNetwork, nil,
-					verror.New(errSendOnExpressQFailed, nil, err))
-			}
-			return err
+	sendPublicKey := func(pubKey *crypto.BoxKey) error {
+		var options []message.SetupOption
+		if pubKey != nil {
+			options = []message.SetupOption{&message.NaclBox{PublicKey: *pubKey}}
 		}
-		if err = vc.HandshakeDialedVC(principal, ver, sendPublicKey, opts...); err != nil {
-			break
-		}
-	case err != nil:
-		break
-	default:
-		err = vif.sendOnExpressQ(&message.OpenVC{
-			VCI:         vc.VCI(),
-			DstEndpoint: remoteEP,
-			SrcEndpoint: vif.localEP,
-			Counters:    counters})
+		err := vif.sendOnExpressQ(&message.SetupVC{
+			VCI:            vc.VCI(),
+			RemoteEndpoint: remoteEP,
+			LocalEndpoint:  vif.localEP,
+			Counters:       counters,
+			Setup: message.Setup{
+				Versions: *vif.versions,
+				Options:  options,
+			},
+		})
 		if err != nil {
-			err = verror.New(stream.ErrNetwork, nil, verror.New(errSendOnExpressQFailed, nil, err))
-			break
+			err = verror.New(stream.ErrNetwork, nil,
+				verror.New(errSendOnExpressQFailed, nil, err))
 		}
-		if err = vc.HandshakeDialedVC(principal, ver, nil, opts...); err != nil {
-			break
-		}
+		return err
 	}
-	if err != nil {
+	if err = vc.HandshakeDialedVC(principal, sendPublicKey, opts...); err != nil {
 		vif.deleteVC(vc.VCI())
 		vc.Close(err)
 		return nil, err
@@ -545,45 +522,6 @@
 			m.Release()
 		}
 
-	case *message.OpenVC:
-		vif.muListen.Lock()
-		closed := vif.acceptor == nil || vif.acceptor.IsClosed()
-		lopts := vif.listenerOpts
-		vif.muListen.Unlock()
-		if closed {
-			vlog.VI(2).Infof("Ignoring OpenVC message %+v as VIF %s does not accept VCs", m, vif)
-			vif.sendOnExpressQ(&message.CloseVC{
-				VCI:   m.VCI,
-				Error: "VCs not accepted",
-			})
-			return nil
-		}
-		var idleTimeout time.Duration
-		for _, o := range lopts {
-			switch v := o.(type) {
-			case vc.IdleTimeout:
-				idleTimeout = v.Duration
-			}
-		}
-		vc, err := vif.newVC(m.VCI, m.DstEndpoint, m.SrcEndpoint, idleTimeout, false)
-		vif.distributeCounters(m.Counters)
-		if err != nil {
-			vif.sendOnExpressQ(&message.CloseVC{
-				VCI:   m.VCI,
-				Error: err.Error(),
-			})
-			return nil
-		}
-		vers, err := vif.versions.CommonVersion(m.DstEndpoint, m.SrcEndpoint)
-		if err != nil {
-			vif.sendOnExpressQ(&message.CloseVC{
-				VCI:   m.VCI,
-				Error: err.Error(),
-			})
-			return nil
-		}
-		go vif.acceptFlowsLoop(vc, vc.HandshakeAcceptedVC(vers, vif.principal, vif.blessings, nil, lopts...))
-
 	case *message.SetupVC:
 		// First, find the public key we need out of the message.
 		var theirPK *crypto.BoxKey
@@ -1159,7 +1097,7 @@
 // localEP creates a naming.Endpoint from the provided parameters.
 //
 // It intentionally does not include any blessings (present in endpoints in the
-// v4 format). At this point it is not clear whether the endpoint is being
+// v5 format). At this point it is not clear whether the endpoint is being
 // created for a "client" or a "server". If the endpoint is used for clients
 // (i.e., for those sending an OpenVC message for example), then we do NOT want
 // to include the blessings in the endpoint to ensure client privacy.
@@ -1173,9 +1111,10 @@
 // clearer.
 func localEP(conn net.Conn, rid naming.RoutingID, versions *iversion.Range) naming.Endpoint {
 	localAddr := conn.LocalAddr()
-	ep := iversion.Endpoint(localAddr.Network(), localAddr.String(), rid)
-	if versions != nil {
-		ep = versions.Endpoint(localAddr.Network(), localAddr.String(), rid)
+	ep := &inaming.Endpoint{
+		Protocol: localAddr.Network(),
+		Address:  localAddr.String(),
+		RID:      rid,
 	}
 	return ep
 }
diff --git a/profiles/internal/rpc/stream/vif/vif_test.go b/profiles/internal/rpc/stream/vif/vif_test.go
index 32ccc74..ba97c3d 100644
--- a/profiles/internal/rpc/stream/vif/vif_test.go
+++ b/profiles/internal/rpc/stream/vif/vif_test.go
@@ -23,6 +23,7 @@
 	"v.io/v23/naming"
 	"v.io/v23/rpc/version"
 
+	inaming "v.io/x/ref/profiles/internal/naming"
 	"v.io/x/ref/profiles/internal/rpc/stream"
 	"v.io/x/ref/profiles/internal/rpc/stream/vc"
 	"v.io/x/ref/profiles/internal/rpc/stream/vif"
@@ -620,7 +621,11 @@
 	}
 	defer client.Close()
 
-	ep := tc.ep.Endpoint("test", "addr", naming.FixedRoutingID(0x5))
+	ep := &inaming.Endpoint{
+		Protocol: "test",
+		Address:  "addr",
+		RID:      naming.FixedRoutingID(0x5),
+	}
 	clientVC, _, err := createVC(client, server, ep)
 	if (err != nil) != tc.expectError {
 		t.Errorf("Error mismatch.  Wanted error: %v, got %v (client:%v, server:%v ep:%v)", tc.expectError, err, tc.client, tc.server, tc.ep)
@@ -689,7 +694,11 @@
 }
 
 func makeEP(rid uint64) naming.Endpoint {
-	return iversion.Endpoint("test", "addr", naming.FixedRoutingID(rid))
+	return &inaming.Endpoint{
+		Protocol: "test",
+		Address:  "addr",
+		RID:      naming.FixedRoutingID(rid),
+	}
 }
 
 // pipeAddr provides a more descriptive String implementation than provided by net.Pipe.
diff --git a/profiles/internal/rpc/version/version.go b/profiles/internal/rpc/version/version.go
index 157ed01..2d3119d 100644
--- a/profiles/internal/rpc/version/version.go
+++ b/profiles/internal/rpc/version/version.go
@@ -5,11 +5,6 @@
 package version
 
 import (
-	"fmt"
-
-	inaming "v.io/x/ref/profiles/internal/naming"
-
-	"v.io/v23/naming"
 	"v.io/v23/rpc/version"
 	"v.io/v23/verror"
 )
@@ -26,21 +21,7 @@
 	// change that's not both forward and backward compatible.
 	// Min should be incremented whenever we want to remove
 	// support for old protocol versions.
-	SupportedRange = &Range{Min: version.RPCVersion6, Max: version.RPCVersion9}
-
-	// Export the methods on supportedRange.
-	Endpoint           = SupportedRange.Endpoint
-	ProxiedEndpoint    = SupportedRange.ProxiedEndpoint
-	CommonVersion      = SupportedRange.CommonVersion
-	CheckCompatibility = SupportedRange.CheckCompatibility
-
-	// Which version to guess servers support if it's unknown.
-	// TODO(mattr): This is a hack.  Once RPCVersion9 is released and versions
-	// are negotiated, we wont have to guess anymore and this code should
-	// be removed.  This is required until version 9 is live.
-	// In fact, once version9 is the minimum supported version, much of the
-	// code in this file can be eliminated.
-	maxVersionGuess = version.RPCVersion8
+	SupportedRange = &Range{Min: version.RPCVersion9, Max: version.RPCVersion9}
 )
 
 const pkgPath = "v.io/x/ref/profiles/internal/rpc/version"
@@ -54,28 +35,15 @@
 	// level errors and hence {1}{2} is omitted from their format
 	// strings to avoid repeating these n-times in the final error
 	// message visible to the user.
-	ErrNoCompatibleVersion         = reg(".errNoCompatibleVersionErr", "no compatible RPC version available{:3} not in range {4}..{5}")
-	ErrUnknownVersion              = reg(".errUnknownVersionErr", "there was not enough information to determine a version")
-	ErrDeprecatedVersion           = reg(".errDeprecatedVersionError", "some of the provided version information is deprecated")
-	errInternalTypeConversionError = reg(".errInternalTypeConversionError", "failed to convert {3} to v.io/ref/profiles/internal/naming.Endpoint {3}")
+	ErrNoCompatibleVersion = reg(".errNoCompatibleVersionErr", "no compatible RPC version available{:3} not in range {4}..{5}")
+	ErrUnknownVersion      = reg(".errUnknownVersionErr", "there was not enough information to determine a version")
+	ErrDeprecatedVersion   = reg(".errDeprecatedVersionError", "some of the provided version information is deprecated")
 )
 
 // IsVersionError returns true if err is a versioning related error.
 func IsVersionError(err error) bool {
 	id := verror.ErrorID(err)
-	return id == ErrNoCompatibleVersion.ID || id == ErrUnknownVersion.ID
-}
-
-// Endpoint returns an endpoint with the Min/MaxRPCVersion properly filled in
-// to match this implementations supported protocol versions.
-func (r *Range) Endpoint(protocol, address string, rid naming.RoutingID) *inaming.Endpoint {
-	return &inaming.Endpoint{
-		Protocol:      protocol,
-		Address:       address,
-		RID:           rid,
-		MinRPCVersion: r.Min,
-		MaxRPCVersion: r.Max,
-	}
+	return id == ErrNoCompatibleVersion.ID || id == ErrUnknownVersion.ID || id == ErrDeprecatedVersion.ID
 }
 
 // intersectRanges finds the intersection between ranges
@@ -105,12 +73,6 @@
 	if max == u || (bmax != u && bmax < max) {
 		max = bmax
 	}
-	// TODO(mattr): This is a hack.  Once RPCVersion9 is released and versions
-	// are negotiated, we wont have to guess anymore and this code should
-	// be removed.  This is required until version 9 is live.
-	if max > maxVersionGuess && (amax == u || bmax == u) {
-		max = maxVersionGuess
-	}
 
 	if min == u || max == u {
 		err = verror.New(ErrUnknownVersion, nil)
@@ -120,10 +82,6 @@
 	return
 }
 
-func intersectEndpoints(a, b *inaming.Endpoint) (min, max version.RPCVersion, err error) {
-	return intersectRanges(a.MinRPCVersion, a.MaxRPCVersion, b.MinRPCVersion, b.MaxRPCVersion)
-}
-
 func (r1 *Range) Intersect(r2 *Range) (*Range, error) {
 	min, max, err := intersectRanges(r1.Min, r1.Max, r2.Min, r2.Max)
 	if err != nil {
@@ -132,77 +90,3 @@
 	r := &Range{Min: min, Max: max}
 	return r, nil
 }
-
-// ProxiedEndpoint returns an endpoint with the Min/MaxRPCVersion properly filled in
-// to match the intersection of capabilities of this process and the proxy.
-func (r *Range) ProxiedEndpoint(rid naming.RoutingID, proxy naming.Endpoint) (*inaming.Endpoint, error) {
-	proxyEP, ok := proxy.(*inaming.Endpoint)
-	if !ok {
-		return nil, verror.New(errInternalTypeConversionError, nil, fmt.Sprintf("%T", proxy))
-	}
-
-	ep := &inaming.Endpoint{
-		Protocol:      proxyEP.Protocol,
-		Address:       proxyEP.Address,
-		RID:           rid,
-		MinRPCVersion: r.Min,
-		MaxRPCVersion: r.Max,
-	}
-
-	// This is the endpoint we are going to advertise.  It should only claim to support versions in
-	// the intersection of those we support and those the proxy supports.
-	var err error
-	ep.MinRPCVersion, ep.MaxRPCVersion, err = intersectEndpoints(ep, proxyEP)
-	if err != nil {
-		return nil, fmt.Errorf("attempting to register with incompatible proxy: %s", proxy)
-	}
-	return ep, nil
-}
-
-// CommonVersion determines which version of the RPC protocol should be used
-// between two endpoints.  Returns an error if the resulting version is incompatible
-// with this RPC implementation.
-func (r *Range) CommonVersion(a, b naming.Endpoint) (version.RPCVersion, error) {
-	aEP, ok := a.(*inaming.Endpoint)
-	if !ok {
-		return 0, verror.New(errInternalTypeConversionError, nil, fmt.Sprintf("%T", a))
-	}
-	bEP, ok := b.(*inaming.Endpoint)
-	if !ok {
-		return 0, verror.New(errInternalTypeConversionError, nil, fmt.Sprintf("%T", b))
-	}
-
-	_, max, err := intersectEndpoints(aEP, bEP)
-	if err != nil {
-		return 0, err
-	}
-
-	// We want to use the maximum common version of the protocol.  We just
-	// need to make sure that it is supported by this RPC implementation.
-	if max < r.Min || max > r.Max {
-		return version.UnknownRPCVersion, verror.New(ErrNoCompatibleVersion, nil, max, r.Min, r.Max)
-	}
-	return max, nil
-}
-
-// CheckCompatibility returns an error if the given endpoint is incompatible
-// with this RPC implementation.  It returns nil otherwise.
-func (r *Range) CheckCompatibility(remote naming.Endpoint) error {
-	remoteEP, ok := remote.(*inaming.Endpoint)
-	if !ok {
-		return verror.New(errInternalTypeConversionError, nil, fmt.Sprintf("%T", remote))
-	}
-
-	if remoteEP.MinRPCVersion == version.DeprecatedRPCVersion &&
-		remoteEP.MaxRPCVersion == version.DeprecatedRPCVersion {
-		// If the remote endpoint no longer contains version information
-		// then compatibility wont be decided here.  We simply return
-		// true and allow the version negotiation to figure it out.
-		return nil
-	}
-
-	_, _, err := intersectRanges(r.Min, r.Max,
-		remoteEP.MinRPCVersion, remoteEP.MaxRPCVersion)
-
-	return err
-}
diff --git a/profiles/internal/rpc/version/version_test.go b/profiles/internal/rpc/version/version_test.go
index a22e6cc..652baf8 100644
--- a/profiles/internal/rpc/version/version_test.go
+++ b/profiles/internal/rpc/version/version_test.go
@@ -6,118 +6,43 @@
 import (
 	"testing"
 
-	inaming "v.io/x/ref/profiles/internal/naming"
-
-	"v.io/v23/naming"
 	"v.io/v23/rpc/version"
 	"v.io/v23/verror"
 )
 
-func TestCommonVersion(t *testing.T) {
-	r := &Range{Min: 2, Max: 4}
-
+func TestIntersect(t *testing.T) {
 	type testCase struct {
 		localMin, localMax   version.RPCVersion
 		remoteMin, remoteMax version.RPCVersion
-		expectedVer          version.RPCVersion
+		expected             *Range
 		expectedErr          verror.IDAction
 	}
 	tests := []testCase{
-		{0, 0, 0, 0, 0, ErrUnknownVersion},
-		{0, 2, 3, 4, 0, ErrNoCompatibleVersion},
-		{3, 4, 0, 2, 0, ErrNoCompatibleVersion},
-		{0, 6, 6, 7, 0, ErrNoCompatibleVersion},
-		{0, 3, 3, 5, 3, verror.ErrUnknown},
-		{0, 3, 2, 4, 3, verror.ErrUnknown},
-		{2, 4, 2, 4, 4, verror.ErrUnknown},
-		{4, 4, 4, 4, 4, verror.ErrUnknown},
+		{0, 0, 0, 0, nil, ErrUnknownVersion},
+		{0, 2, 3, 4, nil, ErrNoCompatibleVersion},
+		{3, 4, 0, 2, nil, ErrNoCompatibleVersion},
+		{0, 6, 6, 7, nil, ErrNoCompatibleVersion},
+		{0, 3, 3, 5, &Range{3, 3}, verror.ErrUnknown},
+		{0, 3, 2, 4, &Range{2, 3}, verror.ErrUnknown},
+		{2, 4, 2, 4, &Range{2, 4}, verror.ErrUnknown},
+		{4, 4, 4, 4, &Range{4, 4}, verror.ErrUnknown},
 	}
 	for _, tc := range tests {
-		local := &inaming.Endpoint{
-			MinRPCVersion: tc.localMin,
-			MaxRPCVersion: tc.localMax,
+		local := &Range{
+			Min: tc.localMin,
+			Max: tc.localMax,
 		}
-		remote := &inaming.Endpoint{
-			MinRPCVersion: tc.remoteMin,
-			MaxRPCVersion: tc.remoteMax,
+		remote := &Range{
+			Min: tc.remoteMin,
+			Max: tc.remoteMax,
 		}
-		ver, err := r.CommonVersion(local, remote)
-		if ver != tc.expectedVer || (err != nil && verror.ErrorID(err) != tc.expectedErr.ID) {
-			t.Errorf("Unexpected result for local: %v, remote: %v.  Got (%d, %v) wanted (%d, %v)",
-				local, remote, ver, err, tc.expectedVer, tc.expectedErr)
-		}
-		if err != nil {
-			t.Logf("%s", err)
-		}
-	}
-}
+		intersection, err := local.Intersect(remote)
 
-func TestProxiedEndpoint(t *testing.T) {
-	type testCase struct {
-		supportMin, supportMax version.RPCVersion
-		proxyMin, proxyMax     version.RPCVersion
-		outMin, outMax         version.RPCVersion
-		expectError            bool
-	}
-	tests := []testCase{
-		{2, 4, 2, 3, 2, 3, false},
-		{2, 4, 4, 6, 4, 4, false},
-		{2, 4, 0, 2, 2, 2, false},
-		{2, 4, 0, 2, 2, 2, false},
-		{0, 0, 0, 0, 0, 0, true},
-		{3, 4, 0, 2, 0, 0, true},
-		{3, 6, 7, 8, 0, 0, true},
-	}
-
-	rid := naming.FixedRoutingID(1)
-	for _, tc := range tests {
-		r := &Range{Min: tc.supportMin, Max: tc.supportMax}
-		proxy := &inaming.Endpoint{
-			MinRPCVersion: tc.proxyMin,
-			MaxRPCVersion: tc.proxyMax,
-		}
-		if ep, err := r.ProxiedEndpoint(rid, proxy); err != nil {
-			if !tc.expectError {
-				t.Errorf("Unexpected error for case %+v: %v", tc, err)
-			}
-		} else {
-			if tc.expectError {
-				t.Errorf("Expected Error, but got result for test case %+v", tc)
-				continue
-			}
-			if ep.MinRPCVersion != tc.outMin || ep.MaxRPCVersion != tc.outMax {
-				t.Errorf("Unexpected range for case %+v.  Got (%d, %d) want (%d, %d)",
-					tc, ep.MinRPCVersion, ep.MaxRPCVersion, tc.outMin, tc.outMax)
-			}
-		}
-	}
-}
-
-func TestCheckCompatibility(t *testing.T) {
-	type testCase struct {
-		supportMin, supportMax version.RPCVersion
-		remoteMin, remoteMax   version.RPCVersion
-		expectedError          verror.IDAction
-	}
-	tests := []testCase{
-		{0, 0, 0, 0, ErrUnknownVersion},
-		{6, 11, 2, 5, ErrNoCompatibleVersion},
-		{2, 5, 6, 11, ErrNoCompatibleVersion},
-		{2, 11, 3, 10, verror.ErrUnknown},
-		{4, 9, 2, 5, verror.ErrUnknown},
-		{4, 9, 8, 10, verror.ErrUnknown},
-	}
-
-	for _, tc := range tests {
-		r := &Range{Min: tc.supportMin, Max: tc.supportMax}
-		remote := &inaming.Endpoint{
-			MinRPCVersion: tc.remoteMin,
-			MaxRPCVersion: tc.remoteMax,
-		}
-		err := r.CheckCompatibility(remote)
-		if err != nil && verror.ErrorID(err) != tc.expectedError.ID {
-			t.Errorf("Unexpected error for case %+v: got %v, wanted %v",
-				tc, err, tc.expectedError)
+		if (tc.expected != nil && *tc.expected != *intersection) ||
+			(err != nil && verror.ErrorID(err) != tc.expectedErr.ID) {
+			t.Errorf("Unexpected result for local: %v, remote: %v.  Got (%v, %v) wanted (%v, %v)",
+				local, remote, intersection, err,
+				tc.expected, tc.expectedErr)
 		}
 		if err != nil {
 			t.Logf("%s", err)