diff --git a/runtimes/google/ipc/client.go b/runtimes/google/ipc/client.go
index 4269466..1d807fe 100644
--- a/runtimes/google/ipc/client.go
+++ b/runtimes/google/ipc/client.go
@@ -115,16 +115,13 @@
 }
 
 func InternalNewClient(streamMgr stream.Manager, ns naming.Namespace, opts ...ipc.ClientOpt) (ipc.Client, error) {
-
 	c := &client{
 		streamMgr: streamMgr,
 		ns:        ns,
 		vcMap:     make(map[string]*vcInfo),
 	}
+	c.dc = InternalNewDischargeClient(nil, c)
 	for _, opt := range opts {
-		if dc, ok := opt.(vc.DischargeClient); ok {
-			c.dc = dc
-		}
 		// Collect all client opts that are also vc opts.
 		switch v := opt.(type) {
 		case stream.VCOpt:
@@ -133,6 +130,7 @@
 			c.preferredProtocols = v
 		}
 	}
+	c.vcOpts = append(c.vcOpts, c.dc)
 
 	return c, nil
 }
@@ -372,7 +370,8 @@
 	var resolveOpts []naming.ResolveOpt
 	if skipResolve {
 		resolveOpts = append(resolveOpts, naming.SkipResolveOpt{})
-	} else if noDischarges {
+	}
+	if noDischarges {
 		resolveOpts = append(resolveOpts, vc.NoDischarges{})
 	}
 
diff --git a/runtimes/google/ipc/discharges.go b/runtimes/google/ipc/discharges.go
index be7641d..09a1abc 100644
--- a/runtimes/google/ipc/discharges.go
+++ b/runtimes/google/ipc/discharges.go
@@ -1,7 +1,6 @@
 package ipc
 
 import (
-	"fmt"
 	"sync"
 
 	"v.io/core/veyron/runtimes/google/ipc/stream/vc"
@@ -9,8 +8,6 @@
 
 	"v.io/core/veyron2/context"
 	"v.io/core/veyron2/ipc"
-	"v.io/core/veyron2/ipc/stream"
-	"v.io/core/veyron2/naming"
 	"v.io/core/veyron2/security"
 	"v.io/core/veyron2/vdl/vdlutil"
 	"v.io/core/veyron2/vlog"
@@ -31,23 +28,14 @@
 // PrepareDischarges call. This typically happens when fetching discharges on
 // behalf of a server accepting connections, i.e., before any notion of the
 // "context" of an API call has been established.
-func InternalNewDischargeClient(streamMgr stream.Manager, ns naming.Namespace, defaultCtx *context.T, opts ...ipc.ClientOpt) (vc.DischargeClient, error) {
-	if defaultCtx == nil {
-		return nil, fmt.Errorf("must provide a non-nil context to InternalNewDischargeClient")
-	}
-	c, err := InternalNewClient(streamMgr, ns, opts...)
-	if err != nil {
-		return nil, err
-	}
+func InternalNewDischargeClient(defaultCtx *context.T, client ipc.Client) vc.DischargeClient {
 	return &dischargeClient{
-		c:          c,
+		c:          client,
 		defaultCtx: defaultCtx,
 		cache:      dischargeCache{cache: make(map[string]security.Discharge)},
-	}, nil
+	}
 }
 
-func (*dischargeClient) IPCClientOpt()         {}
-func (*dischargeClient) IPCServerOpt()         {}
 func (*dischargeClient) IPCStreamListenerOpt() {}
 func (*dischargeClient) IPCStreamVCOpt()       {}
 
diff --git a/runtimes/google/ipc/full_test.go b/runtimes/google/ipc/full_test.go
index cd6ac56..259a45e 100644
--- a/runtimes/google/ipc/full_test.go
+++ b/runtimes/google/ipc/full_test.go
@@ -452,15 +452,7 @@
 		}
 	)
 
-	ctx := testContextWithoutDeadline()
-
-	// Start the main server.
-	dc, err := InternalNewDischargeClient(mgr, ns, ctx, vc.LocalPrincipal{pserver})
-	if err != nil {
-		t.Errorf("InternalNewDischargeClient failed: %v", err)
-	}
-
-	_, server := startServer(t, pserver, mgr, ns, serverName, testServerDisp{&testServer{}}, dc)
+	_, server := startServer(t, pserver, mgr, ns, serverName, testServerDisp{&testServer{}})
 	defer stopServer(t, server, ns, serverName)
 
 	// Start the discharge server.
@@ -487,6 +479,7 @@
 			t.Errorf("%s: failed to create client: %v", name, err)
 			continue
 		}
+		ctx := testContextWithoutDeadline()
 		dctx, cancel := ctx.WithTimeout(10 * time.Second)
 		call, err := client.StartCall(dctx, fmt.Sprintf("[%s]%s/suffix", test.pattern, serverName), "Method", nil)
 		if !matchesErrorPattern(err, test.errID, test.err) {
@@ -777,12 +770,6 @@
 		t.Fatal(err)
 	}
 
-	// DischargeClient used to fetch discharges.
-	dc, err := InternalNewDischargeClient(sm, ns, testContext(), vc.LocalPrincipal{pclient})
-	if err != nil {
-		t.Fatalf("InternalDischargeNewClient failed: %v", err)
-	}
-
 	// Setup the application server.
 	appServer, err := InternalNewServer(testContext(), sm, ns, nil, vc.LocalPrincipal{pserver})
 	if err != nil {
@@ -832,7 +819,7 @@
 
 	for testidx, test := range tests {
 		pclient := mkClient(test.Requirements)
-		client, err := InternalNewClient(sm, ns, pclient, dc)
+		client, err := InternalNewClient(sm, ns, pclient)
 		if err != nil {
 			t.Fatalf("InternalNewClient(%+v) failed: %v", test.Requirements, err)
 		}
@@ -990,11 +977,7 @@
 
 	for _, test := range tests {
 		name := fmt.Sprintf("%q.%s(%v) by %v", test.name, test.method, test.args, test.blessings)
-		dc, err := InternalNewDischargeClient(mgr, ns, testContext(), vc.LocalPrincipal{pclient})
-		if err != nil {
-			t.Errorf("InternalNewDischargeClient failed: %v", err)
-		}
-		client, err := InternalNewClient(mgr, ns, vc.LocalPrincipal{pclient}, dc)
+		client, err := InternalNewClient(mgr, ns, vc.LocalPrincipal{pclient})
 		if err != nil {
 			t.Fatalf("InternalNewClient failed: %v", err)
 		}
@@ -1035,11 +1018,8 @@
 	b := createBundle(t, nil, pserver, &testServer{})
 	defer b.cleanup(t)
 
-	dc, err := InternalNewDischargeClient(b.sm, b.ns, testContext(), vc.LocalPrincipal{pclient})
-	if err != nil {
-		t.Fatalf("InternalNewDischargeClient failed: %v", err)
-	}
-	if b.client, err = InternalNewClient(b.sm, b.ns, vc.LocalPrincipal{pclient}, dc); err != nil {
+	var err error
+	if b.client, err = InternalNewClient(b.sm, b.ns, vc.LocalPrincipal{pclient}); err != nil {
 		t.Fatalf("InternalNewClient failed: %v", err)
 	}
 	call := func() verror.E {
@@ -1508,11 +1488,7 @@
 		}
 		smc := imanager.InternalNew(rid)
 		defer smc.Shutdown()
-		dc, err := InternalNewDischargeClient(smc, ns, testContext())
-		if err != nil {
-			t.Fatal(err)
-		}
-		client, err := InternalNewClient(smc, ns, vc.LocalPrincipal{pclient}, dc)
+		client, err := InternalNewClient(smc, ns, vc.LocalPrincipal{pclient})
 		if err != nil {
 			t.Fatalf("failed to create client: %v", err)
 		}
@@ -1586,10 +1562,12 @@
 		t.Fatal(err)
 	}
 	sm := imanager.InternalNew(rid)
-	dc, err := InternalNewDischargeClient(sm, ns, testContext(), vc.LocalPrincipal{pdischargeClient})
+
+	c, err := InternalNewClient(sm, ns, vc.LocalPrincipal{pdischargeClient})
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("failed to create client: %v", err)
 	}
+	dc := c.(*client).dc
 	tpcav2, err := security.NewPublicKeyCaveat(pdischarger2.PublicKey(), "mountpoint/discharger2", security.ThirdPartyRequirements{}, mkCaveat(security.ExpiryCaveat(time.Now().Add(time.Hour))))
 	if err != nil {
 		t.Error(err)
diff --git a/runtimes/google/ipc/server.go b/runtimes/google/ipc/server.go
index ca3b7c8..0b85a52 100644
--- a/runtimes/google/ipc/server.go
+++ b/runtimes/google/ipc/server.go
@@ -123,6 +123,13 @@
 			s.preferredProtocols = []string(opt)
 		}
 	}
+	// TODO(suharshs,mattr): Get a client from the context.
+	client, err := InternalNewClient(streamMgr, ns)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create discharge-client: %v", err)
+	}
+	dc := InternalNewDischargeClient(ctx, client)
+	s.listenerOpts = append(s.listenerOpts, dc)
 	blessingsStatsName := naming.Join(statsPrefix, "security", "blessings")
 	if blessings != nil {
 		// TODO(caprita): revist printing the blessings with %s, and
diff --git a/runtimes/google/ipc/stream/vc/vc.go b/runtimes/google/ipc/stream/vc/vc.go
index a52585b..e9521b5 100644
--- a/runtimes/google/ipc/stream/vc/vc.go
+++ b/runtimes/google/ipc/stream/vc/vc.go
@@ -126,8 +126,6 @@
 	// Invalidate marks the provided discharges as invalid, and therefore unfit
 	// for being returned by a subsequent PrepareDischarges call.
 	Invalidate(discharges ...security.Discharge)
-	IPCServerOpt()
-	IPCClientOpt()
 	IPCStreamListenerOpt()
 	IPCStreamVCOpt()
 }
diff --git a/runtimes/google/ipc/stream/vc/vc_test.go b/runtimes/google/ipc/stream/vc/vc_test.go
index ab6a300..3c05f16 100644
--- a/runtimes/google/ipc/stream/vc/vc_test.go
+++ b/runtimes/google/ipc/stream/vc/vc_test.go
@@ -171,8 +171,6 @@
 func (mockDischargeClient) Invalidate(...security.Discharge) {}
 func (mockDischargeClient) IPCStreamListenerOpt()            {}
 func (mockDischargeClient) IPCStreamVCOpt()                  {}
-func (mockDischargeClient) IPCServerOpt()                    {}
-func (mockDischargeClient) IPCClientOpt()                    {}
 
 // Test that mockDischargeClient implements vc.DischargeClient.
 var _ vc.DischargeClient = (mockDischargeClient)(nil)
diff --git a/runtimes/google/rt/ipc.go b/runtimes/google/rt/ipc.go
index 227455e..6e4439f 100644
--- a/runtimes/google/rt/ipc.go
+++ b/runtimes/google/rt/ipc.go
@@ -37,12 +37,7 @@
 		}
 	}
 	otherOpts = append(otherOpts, vc.LocalPrincipal{rt.principal}, &imanager.DialTimeout{5 * time.Minute}, rt.preferredProtocols)
-
-	dc, err := iipc.InternalNewDischargeClient(sm, ns, rt.NewContext(), otherOpts...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create discharge-client: %v", err)
-	}
-	return iipc.InternalNewClient(sm, ns, append(otherOpts, dc)...)
+	return iipc.InternalNewClient(sm, ns, otherOpts...)
 }
 
 func (rt *vrt) Client() ipc.Client {
@@ -113,16 +108,8 @@
 	if len(rt.preferredProtocols) > 0 {
 		otherOpts = append(otherOpts, iipc.PreferredServerResolveProtocols(rt.preferredProtocols))
 	}
-
-	// Add the option that provides a discharge client to the server.
-	// TODO(cnicolaou): extend the timeout when parallel connections are
-	// going.
 	ctx := rt.NewContext()
-	dc, err := iipc.InternalNewDischargeClient(sm, ns, ctx, vc.LocalPrincipal{rt.principal}, &imanager.DialTimeout{5 * time.Second})
-	if err != nil {
-		return nil, fmt.Errorf("failed to create discharge-client: %v", err)
-	}
-	return iipc.InternalNewServer(ctx, sm, ns, rt.traceStore, append(otherOpts, dc)...)
+	return iipc.InternalNewServer(ctx, sm, ns, rt.traceStore, otherOpts...)
 }
 
 func (rt *vrt) NewStreamManager(opts ...stream.ManagerOpt) (stream.Manager, error) {