diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 35c81d5..9619fad 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -22,6 +22,7 @@
 
 FakeProofSource::GetProofOp::GetProofOp(
     const QuicSocketAddress& server_addr,
+    const QuicSocketAddress& client_address,
     std::string hostname,
     std::string server_config,
     QuicTransportVersion transport_version,
@@ -29,6 +30,7 @@
     std::unique_ptr<ProofSource::Callback> callback,
     ProofSource* delegate)
     : server_address_(server_addr),
+      client_address_(client_address),
       hostname_(std::move(hostname)),
       server_config_(std::move(server_config)),
       transport_version_(transport_version),
@@ -40,18 +42,21 @@
 
 void FakeProofSource::GetProofOp::Run() {
   // Note: relies on the callback being invoked synchronously
-  delegate_->GetProof(server_address_, hostname_, server_config_,
-                      transport_version_, chlo_hash_, std::move(callback_));
+  delegate_->GetProof(server_address_, client_address_, hostname_,
+                      server_config_, transport_version_, chlo_hash_,
+                      std::move(callback_));
 }
 
 FakeProofSource::ComputeSignatureOp::ComputeSignatureOp(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     std::string hostname,
     uint16_t sig_alg,
     quiche::QuicheStringPiece in,
     std::unique_ptr<ProofSource::SignatureCallback> callback,
     ProofSource* delegate)
     : server_address_(server_address),
+      client_address_(client_address),
       hostname_(std::move(hostname)),
       sig_alg_(sig_alg),
       in_(in),
@@ -61,8 +66,8 @@
 FakeProofSource::ComputeSignatureOp::~ComputeSignatureOp() = default;
 
 void FakeProofSource::ComputeSignatureOp::Run() {
-  delegate_->ComputeTlsSignature(server_address_, hostname_, sig_alg_, in_,
-                                 std::move(callback_));
+  delegate_->ComputeTlsSignature(server_address_, client_address_, hostname_,
+                                 sig_alg_, in_, std::move(callback_));
 }
 
 void FakeProofSource::Activate() {
@@ -71,30 +76,34 @@
 
 void FakeProofSource::GetProof(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname,
     const std::string& server_config,
     QuicTransportVersion transport_version,
     quiche::QuicheStringPiece chlo_hash,
     std::unique_ptr<ProofSource::Callback> callback) {
   if (!active_) {
-    delegate_->GetProof(server_address, hostname, server_config,
+    delegate_->GetProof(server_address, client_address, hostname, server_config,
                         transport_version, chlo_hash, std::move(callback));
     return;
   }
 
   pending_ops_.push_back(std::make_unique<GetProofOp>(
-      server_address, hostname, server_config, transport_version,
-      std::string(chlo_hash), std::move(callback), delegate_.get()));
+      server_address, client_address, hostname, server_config,
+      transport_version, std::string(chlo_hash), std::move(callback),
+      delegate_.get()));
 }
 
 QuicReferenceCountedPointer<ProofSource::Chain> FakeProofSource::GetCertChain(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname) {
-  return delegate_->GetCertChain(server_address, hostname);
+  return delegate_->GetCertChain(server_address, client_address, hostname);
 }
 
 void FakeProofSource::ComputeTlsSignature(
     const QuicSocketAddress& server_address,
+    const QuicSocketAddress& client_address,
     const std::string& hostname,
     uint16_t signature_algorithm,
     quiche::QuicheStringPiece in,
@@ -102,15 +111,16 @@
   QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
   if (!active_) {
     QUIC_LOG(INFO) << "Not active - directly calling delegate";
-    delegate_->ComputeTlsSignature(
-        server_address, hostname, signature_algorithm, in, std::move(callback));
+    delegate_->ComputeTlsSignature(server_address, client_address, hostname,
+                                   signature_algorithm, in,
+                                   std::move(callback));
     return;
   }
 
   QUIC_LOG(INFO) << "Adding pending op";
   pending_ops_.push_back(std::make_unique<ComputeSignatureOp>(
-      server_address, hostname, signature_algorithm, in, std::move(callback),
-      delegate_.get()));
+      server_address, client_address, hostname, signature_algorithm, in,
+      std::move(callback), delegate_.get()));
 }
 
 ProofSource::TicketCrypter* FakeProofSource::GetTicketCrypter() {