diff --git a/build/source_list.bzl b/build/source_list.bzl
index 465be42..83c2a51 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -1625,14 +1625,15 @@
     "blind_sign_auth/blind_sign_auth.h",
     "blind_sign_auth/blind_sign_auth_interface.h",
     "blind_sign_auth/blind_sign_auth_protos.h",
-    "blind_sign_auth/blind_sign_http_response.h",
     "blind_sign_auth/blind_sign_message_interface.h",
+    "blind_sign_auth/blind_sign_message_response.h",
     "blind_sign_auth/cached_blind_sign_auth.h",
     "blind_sign_auth/test_tools/mock_blind_sign_auth_interface.h",
-    "blind_sign_auth/test_tools/mock_blind_sign_http_interface.h",
+    "blind_sign_auth/test_tools/mock_blind_sign_message_interface.h",
 ]
 blind_sign_auth_srcs = [
     "blind_sign_auth/blind_sign_auth.cc",
+    "blind_sign_auth/blind_sign_message_response.cc",
     "blind_sign_auth/cached_blind_sign_auth.cc",
 ]
 blind_sign_auth_tests_hdrs = [
diff --git a/build/source_list.gni b/build/source_list.gni
index 1bb50dd..70587e1 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -1629,14 +1629,15 @@
     "src/quiche/blind_sign_auth/blind_sign_auth.h",
     "src/quiche/blind_sign_auth/blind_sign_auth_interface.h",
     "src/quiche/blind_sign_auth/blind_sign_auth_protos.h",
-    "src/quiche/blind_sign_auth/blind_sign_http_response.h",
     "src/quiche/blind_sign_auth/blind_sign_message_interface.h",
+    "src/quiche/blind_sign_auth/blind_sign_message_response.h",
     "src/quiche/blind_sign_auth/cached_blind_sign_auth.h",
     "src/quiche/blind_sign_auth/test_tools/mock_blind_sign_auth_interface.h",
-    "src/quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h",
+    "src/quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h",
 ]
 blind_sign_auth_srcs = [
     "src/quiche/blind_sign_auth/blind_sign_auth.cc",
+    "src/quiche/blind_sign_auth/blind_sign_message_response.cc",
     "src/quiche/blind_sign_auth/cached_blind_sign_auth.cc",
 ]
 blind_sign_auth_tests_hdrs = [
diff --git a/build/source_list.json b/build/source_list.json
index fb45e82..191c426 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -1628,14 +1628,15 @@
     "quiche/blind_sign_auth/blind_sign_auth.h",
     "quiche/blind_sign_auth/blind_sign_auth_interface.h",
     "quiche/blind_sign_auth/blind_sign_auth_protos.h",
-    "quiche/blind_sign_auth/blind_sign_http_response.h",
     "quiche/blind_sign_auth/blind_sign_message_interface.h",
+    "quiche/blind_sign_auth/blind_sign_message_response.h",
     "quiche/blind_sign_auth/cached_blind_sign_auth.h",
     "quiche/blind_sign_auth/test_tools/mock_blind_sign_auth_interface.h",
-    "quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h"
+    "quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h"
   ],
   "blind_sign_auth_srcs": [
     "quiche/blind_sign_auth/blind_sign_auth.cc",
+    "quiche/blind_sign_auth/blind_sign_message_response.cc",
     "quiche/blind_sign_auth/cached_blind_sign_auth.cc"
   ],
   "blind_sign_auth_tests_hdrs": [
diff --git a/quiche/blind_sign_auth/blind_sign_auth.cc b/quiche/blind_sign_auth/blind_sign_auth.cc
index 898fcfd..b52367e 100644
--- a/quiche/blind_sign_auth/blind_sign_auth.cc
+++ b/quiche/blind_sign_auth/blind_sign_auth.cc
@@ -28,8 +28,8 @@
 #include "anonymous_tokens/cpp/shared/proto_utils.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_protos.h"
-#include "quiche/blind_sign_auth/blind_sign_http_response.h"
 #include "quiche/blind_sign_auth/blind_sign_message_interface.h"
+#include "quiche/blind_sign_auth/blind_sign_message_response.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_random.h"
 
@@ -60,27 +60,27 @@
   request.set_validation_version(2);
   request.set_proxy_layer(QuicheProxyLayerToPpnProxyLayer(proxy_layer));
 
-  // Call GetInitialData on the HttpFetcher.
+  // Call GetInitialData on the BlindSignMessageInterface Fetcher.
   std::string body = request.SerializeAsString();
-  BlindSignHttpCallback initial_data_callback = absl::bind_front(
+  BlindSignMessageCallback initial_data_callback = absl::bind_front(
       &BlindSignAuth::GetInitialDataCallback, this, oauth_token, num_tokens,
       proxy_layer, service_type, std::move(callback));
-  http_fetcher_->DoRequest(BlindSignHttpRequestType::kGetInitialData,
-                           oauth_token, body, std::move(initial_data_callback));
+  fetcher_->DoRequest(BlindSignMessageRequestType::kGetInitialData, oauth_token,
+                      body, std::move(initial_data_callback));
 }
 
 void BlindSignAuth::GetInitialDataCallback(
     std::optional<std::string> oauth_token, int num_tokens,
     ProxyLayer proxy_layer, BlindSignAuthServiceType service_type,
     SignedTokenCallback callback,
-    absl::StatusOr<BlindSignHttpResponse> response) {
+    absl::StatusOr<BlindSignMessageResponse> response) {
   if (!response.ok()) {
     QUICHE_LOG(WARNING) << "GetInitialDataRequest failed: "
                         << response.status();
     std::move(callback)(response.status());
     return;
   }
-  absl::StatusCode code = HttpCodeToStatusCode(response->status_code());
+  absl::StatusCode code = response->status_code();
   if (code != absl::StatusCode::kOk) {
     std::string message =
         absl::StrCat("GetInitialDataRequest failed with code: ", code);
@@ -244,16 +244,16 @@
     return;
   }
 
-  BlindSignHttpCallback auth_and_sign_callback =
+  BlindSignMessageCallback auth_and_sign_callback =
       absl::bind_front(&BlindSignAuth::PrivacyPassAuthAndSignCallback, this,
                        std::move(initial_data_response.privacy_pass_data()
                                      .public_metadata_extensions()),
                        public_metadata_expiry_time, *use_case,
                        std::move(privacy_pass_clients), std::move(callback));
   // TODO(b/304811277): remove other usages of string.data()
-  http_fetcher_->DoRequest(BlindSignHttpRequestType::kAuthAndSign, oauth_token,
-                           sign_request.SerializeAsString(),
-                           std::move(auth_and_sign_callback));
+  fetcher_->DoRequest(BlindSignMessageRequestType::kAuthAndSign, oauth_token,
+                      sign_request.SerializeAsString(),
+                      std::move(auth_and_sign_callback));
 }
 
 void BlindSignAuth::PrivacyPassAuthAndSignCallback(
@@ -263,14 +263,14 @@
                                     PrivacyPassRsaBssaPublicMetadataClient>>
         privacy_pass_clients,
     SignedTokenCallback callback,
-    absl::StatusOr<BlindSignHttpResponse> response) {
+    absl::StatusOr<BlindSignMessageResponse> response) {
   // Validate response.
   if (!response.ok()) {
     QUICHE_LOG(WARNING) << "AuthAndSign failed: " << response.status();
     std::move(callback)(response.status());
     return;
   }
-  absl::StatusCode code = HttpCodeToStatusCode(response->status_code());
+  absl::StatusCode code = response->status_code();
   if (code != absl::StatusCode::kOk) {
     std::string message = absl::StrCat("AuthAndSign failed with code: ", code);
     QUICHE_LOG(WARNING) << message;
@@ -338,44 +338,6 @@
   std::move(callback)(absl::Span<BlindSignToken>(tokens_vec));
 }
 
-absl::StatusCode BlindSignAuth::HttpCodeToStatusCode(int http_code) {
-  // copybara:strip_begin(golink)
-  // This mapping is from go/http-canonical-mapping
-  // copybara:strip_end
-  if (http_code >= 200 && http_code < 300) {
-    return absl::StatusCode::kOk;
-  } else if (http_code >= 300 && http_code < 400) {
-    return absl::StatusCode::kUnknown;
-  } else if (http_code == 400) {
-    return absl::StatusCode::kInvalidArgument;
-  } else if (http_code == 401) {
-    return absl::StatusCode::kUnauthenticated;
-  } else if (http_code == 403) {
-    return absl::StatusCode::kPermissionDenied;
-  } else if (http_code == 404) {
-    return absl::StatusCode::kNotFound;
-  } else if (http_code == 409) {
-    return absl::StatusCode::kAborted;
-  } else if (http_code == 416) {
-    return absl::StatusCode::kOutOfRange;
-  } else if (http_code == 429) {
-    return absl::StatusCode::kResourceExhausted;
-  } else if (http_code == 499) {
-    return absl::StatusCode::kCancelled;
-  } else if (http_code >= 400 && http_code < 500) {
-    return absl::StatusCode::kFailedPrecondition;
-  } else if (http_code == 501) {
-    return absl::StatusCode::kUnimplemented;
-  } else if (http_code == 503) {
-    return absl::StatusCode::kUnavailable;
-  } else if (http_code == 504) {
-    return absl::StatusCode::kDeadlineExceeded;
-  } else if (http_code >= 500 && http_code < 600) {
-    return absl::StatusCode::kInternal;
-  }
-  return absl::StatusCode::kUnknown;
-}
-
 privacy::ppn::ProxyLayer BlindSignAuth::QuicheProxyLayerToPpnProxyLayer(
     quiche::ProxyLayer proxy_layer) {
   switch (proxy_layer) {
diff --git a/quiche/blind_sign_auth/blind_sign_auth.h b/quiche/blind_sign_auth/blind_sign_auth.h
index ab223ad..552f2c1 100644
--- a/quiche/blind_sign_auth/blind_sign_auth.h
+++ b/quiche/blind_sign_auth/blind_sign_auth.h
@@ -9,14 +9,13 @@
 #include <optional>
 #include <string>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/time/time.h"
 #include "anonymous_tokens/cpp/privacy_pass/rsa_bssa_public_metadata_client.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_protos.h"
-#include "quiche/blind_sign_auth/blind_sign_http_response.h"
 #include "quiche/blind_sign_auth/blind_sign_message_interface.h"
+#include "quiche/blind_sign_auth/blind_sign_message_response.h"
 #include "quiche/common/platform/api/quiche_export.h"
 
 namespace quiche {
@@ -24,14 +23,12 @@
 // BlindSignAuth provides signed, unblinded tokens to callers.
 class QUICHE_EXPORT BlindSignAuth : public BlindSignAuthInterface {
  public:
-  explicit BlindSignAuth(BlindSignMessageInterface* http_fetcher,
+  explicit BlindSignAuth(BlindSignMessageInterface* fetcher,
                          privacy::ppn::BlindSignAuthOptions auth_options)
-      : http_fetcher_(http_fetcher), auth_options_(std::move(auth_options)) {}
+      : fetcher_(fetcher), auth_options_(std::move(auth_options)) {}
 
   // Returns signed unblinded tokens and their expiration time in a callback.
   // Tokens are single-use.
-  // GetTokens starts asynchronous HTTP POST requests to a signer hostname
-  // specified by the caller, with path and query params given in the request.
   // The GetTokens callback will run on the same thread as the
   // BlindSignMessageInterface callbacks.
   // Callers can make multiple concurrent requests to GetTokens.
@@ -40,11 +37,11 @@
                  SignedTokenCallback callback) override;
 
  private:
-  void GetInitialDataCallback(std::optional<std::string> oauth_token,
-                              int num_tokens, ProxyLayer proxy_layer,
-                              BlindSignAuthServiceType service_type,
-                              SignedTokenCallback callback,
-                              absl::StatusOr<BlindSignHttpResponse> response);
+  void GetInitialDataCallback(
+      std::optional<std::string> oauth_token, int num_tokens,
+      ProxyLayer proxy_layer, BlindSignAuthServiceType service_type,
+      SignedTokenCallback callback,
+      absl::StatusOr<BlindSignMessageResponse> response);
   void GeneratePrivacyPassTokens(
       privacy::ppn::GetInitialDataResponse initial_data_response,
       std::optional<std::string> oauth_token, int num_tokens,
@@ -57,12 +54,11 @@
                                       PrivacyPassRsaBssaPublicMetadataClient>>
           privacy_pass_clients,
       SignedTokenCallback callback,
-      absl::StatusOr<BlindSignHttpResponse> response);
-  absl::StatusCode HttpCodeToStatusCode(int http_code);
+      absl::StatusOr<BlindSignMessageResponse> response);
   privacy::ppn::ProxyLayer QuicheProxyLayerToPpnProxyLayer(
       quiche::ProxyLayer proxy_layer);
 
-  BlindSignMessageInterface* http_fetcher_ = nullptr;
+  BlindSignMessageInterface* fetcher_ = nullptr;
   privacy::ppn::BlindSignAuthOptions auth_options_;
 };
 
diff --git a/quiche/blind_sign_auth/blind_sign_auth_test.cc b/quiche/blind_sign_auth/blind_sign_auth_test.cc
index 24d6d15..6e01b5c 100644
--- a/quiche/blind_sign_auth/blind_sign_auth_test.cc
+++ b/quiche/blind_sign_auth/blind_sign_auth_test.cc
@@ -21,9 +21,9 @@
 #include "openssl/digest.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_interface.h"
 #include "quiche/blind_sign_auth/blind_sign_auth_protos.h"
-#include "quiche/blind_sign_auth/blind_sign_http_response.h"
 #include "quiche/blind_sign_auth/blind_sign_message_interface.h"
-#include "quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h"
+#include "quiche/blind_sign_auth/blind_sign_message_response.h"
+#include "quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h"
 #include "quiche/common/platform/api/quiche_mutex.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
@@ -159,7 +159,7 @@
     options.set_enable_privacy_pass(true);
 
     blind_sign_auth_ =
-        std::make_unique<BlindSignAuth>(&mock_http_interface_, options);
+        std::make_unique<BlindSignAuth>(&mock_message_interface_, options);
   }
 
   void TearDown() override { blind_sign_auth_.reset(nullptr); }
@@ -246,7 +246,7 @@
     }
   }
 
-  MockBlindSignHttpInterface mock_http_interface_;
+  MockBlindSignMessageInterface mock_message_interface_;
   std::unique_ptr<BlindSignAuth> blind_sign_auth_;
   anonymous_tokens::RSABlindSignaturePublicKey
       public_key_proto_;
@@ -262,8 +262,8 @@
 };
 
 TEST_F(BlindSignAuthTest, TestGetTokensFailedNetworkError) {
-  EXPECT_CALL(mock_http_interface_,
-              DoRequest(Eq(BlindSignHttpRequestType::kGetInitialData),
+  EXPECT_CALL(mock_message_interface_,
+              DoRequest(Eq(BlindSignMessageRequestType::kGetInitialData),
                         Eq(oauth_token_), _, _))
       .Times(1)
       .WillOnce([=](auto&&, auto&&, auto&&, auto get_initial_data_cb) {
@@ -271,8 +271,8 @@
             absl::InternalError("Failed to create socket"));
       });
 
-  EXPECT_CALL(mock_http_interface_,
-              DoRequest(Eq(BlindSignHttpRequestType::kAuthAndSign), _, _, _))
+  EXPECT_CALL(mock_message_interface_,
+              DoRequest(Eq(BlindSignMessageRequestType::kAuthAndSign), _, _, _))
       .Times(0);
 
   int num_tokens = 1;
@@ -292,20 +292,22 @@
   *fake_get_initial_data_response_.mutable_at_public_metadata_public_key()
        ->mutable_use_case() = "SPAM";
 
-  BlindSignHttpResponse fake_public_key_response(
-      200, fake_get_initial_data_response_.SerializeAsString());
+  BlindSignMessageResponse fake_public_key_response(
+      absl::StatusCode::kOk,
+      fake_get_initial_data_response_.SerializeAsString());
 
   EXPECT_CALL(
-      mock_http_interface_,
-      DoRequest(Eq(BlindSignHttpRequestType::kGetInitialData), Eq(oauth_token_),
+      mock_message_interface_,
+      DoRequest(Eq(BlindSignMessageRequestType::kGetInitialData),
+                Eq(oauth_token_),
                 Eq(expected_get_initial_data_request_.SerializeAsString()), _))
       .Times(1)
       .WillOnce([=](auto&&, auto&&, auto&&, auto get_initial_data_cb) {
         std::move(get_initial_data_cb)(fake_public_key_response);
       });
 
-  EXPECT_CALL(mock_http_interface_,
-              DoRequest(Eq(BlindSignHttpRequestType::kAuthAndSign), _, _, _))
+  EXPECT_CALL(mock_message_interface_,
+              DoRequest(Eq(BlindSignMessageRequestType::kAuthAndSign), _, _, _))
       .Times(0);
 
   int num_tokens = 1;
@@ -322,33 +324,34 @@
 }
 
 TEST_F(BlindSignAuthTest, TestGetTokensFailedBadAuthAndSignResponse) {
-  BlindSignHttpResponse fake_public_key_response(
-      200, fake_get_initial_data_response_.SerializeAsString());
+  BlindSignMessageResponse fake_public_key_response(
+      absl::StatusCode::kOk,
+      fake_get_initial_data_response_.SerializeAsString());
   {
     InSequence seq;
 
     EXPECT_CALL(
-        mock_http_interface_,
+        mock_message_interface_,
         DoRequest(
-            Eq(BlindSignHttpRequestType::kGetInitialData), Eq(oauth_token_),
+            Eq(BlindSignMessageRequestType::kGetInitialData), Eq(oauth_token_),
             Eq(expected_get_initial_data_request_.SerializeAsString()), _))
         .Times(1)
         .WillOnce([=](auto&&, auto&&, auto&&, auto get_initial_data_cb) {
           std::move(get_initial_data_cb)(fake_public_key_response);
         });
 
-    EXPECT_CALL(mock_http_interface_,
-                DoRequest(Eq(BlindSignHttpRequestType::kAuthAndSign),
+    EXPECT_CALL(mock_message_interface_,
+                DoRequest(Eq(BlindSignMessageRequestType::kAuthAndSign),
                           Eq(oauth_token_), _, _))
         .Times(1)
         .WillOnce(Invoke([this](Unused, Unused, const std::string& body,
-                                BlindSignHttpCallback callback) {
+                                BlindSignMessageCallback callback) {
           CreateSignResponse(body, false);
           // Add an invalid signature that can't be Base64 decoded.
           sign_response_.add_blinded_token_signature("invalid_signature%");
-          BlindSignHttpResponse http_response(
-              200, sign_response_.SerializeAsString());
-          std::move(callback)(http_response);
+          BlindSignMessageResponse response(absl::StatusCode::kOk,
+                                            sign_response_.SerializeAsString());
+          std::move(callback)(response);
         }));
   }
 
@@ -366,31 +369,32 @@
 }
 
 TEST_F(BlindSignAuthTest, TestPrivacyPassGetTokensSucceeds) {
-  BlindSignHttpResponse fake_public_key_response(
-      200, fake_get_initial_data_response_.SerializeAsString());
+  BlindSignMessageResponse fake_public_key_response(
+      absl::StatusCode::kOk,
+      fake_get_initial_data_response_.SerializeAsString());
   {
     InSequence seq;
 
     EXPECT_CALL(
-        mock_http_interface_,
+        mock_message_interface_,
         DoRequest(
-            Eq(BlindSignHttpRequestType::kGetInitialData), Eq(oauth_token_),
+            Eq(BlindSignMessageRequestType::kGetInitialData), Eq(oauth_token_),
             Eq(expected_get_initial_data_request_.SerializeAsString()), _))
         .Times(1)
         .WillOnce([=](auto&&, auto&&, auto&&, auto get_initial_data_cb) {
           std::move(get_initial_data_cb)(fake_public_key_response);
         });
 
-    EXPECT_CALL(mock_http_interface_,
-                DoRequest(Eq(BlindSignHttpRequestType::kAuthAndSign),
+    EXPECT_CALL(mock_message_interface_,
+                DoRequest(Eq(BlindSignMessageRequestType::kAuthAndSign),
                           Eq(oauth_token_), _, _))
         .Times(1)
         .WillOnce(Invoke([this](Unused, Unused, const std::string& body,
-                                BlindSignHttpCallback callback) {
+                                BlindSignMessageCallback callback) {
           CreateSignResponse(body, /*use_privacy_pass=*/true);
-          BlindSignHttpResponse http_response(
-              200, sign_response_.SerializeAsString());
-          std::move(callback)(http_response);
+          BlindSignMessageResponse response(absl::StatusCode::kOk,
+                                            sign_response_.SerializeAsString());
+          std::move(callback)(response);
         }));
   }
 
@@ -412,7 +416,7 @@
   privacy::ppn::BlindSignAuthOptions options;
   options.set_enable_privacy_pass(true);
   blind_sign_auth_ =
-      std::make_unique<BlindSignAuth>(&mock_http_interface_, options);
+      std::make_unique<BlindSignAuth>(&mock_message_interface_, options);
 
   public_key_proto_.set_message_mask_type(
       anonymous_tokens::AT_MESSAGE_MASK_NO_MASK);
@@ -421,12 +425,14 @@
       public_key_proto_;
   fake_get_initial_data_response_.mutable_privacy_pass_data()
       ->set_public_metadata_extensions("spam");
-  BlindSignHttpResponse fake_public_key_response(
-      200, fake_get_initial_data_response_.SerializeAsString());
+  BlindSignMessageResponse fake_public_key_response(
+      absl::StatusCode::kOk,
+      fake_get_initial_data_response_.SerializeAsString());
 
   EXPECT_CALL(
-      mock_http_interface_,
-      DoRequest(Eq(BlindSignHttpRequestType::kGetInitialData), Eq(oauth_token_),
+      mock_message_interface_,
+      DoRequest(Eq(BlindSignMessageRequestType::kGetInitialData),
+                Eq(oauth_token_),
                 Eq(expected_get_initial_data_request_.SerializeAsString()), _))
       .Times(1)
       .WillOnce([=](auto&&, auto&&, auto&&, auto get_initial_data_cb) {
diff --git a/quiche/blind_sign_auth/blind_sign_http_response.h b/quiche/blind_sign_auth/blind_sign_http_response.h
deleted file mode 100644
index 89d9072..0000000
--- a/quiche/blind_sign_auth/blind_sign_http_response.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2023 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_HTTP_RESPONSE_H_
-#define QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_HTTP_RESPONSE_H_
-
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "quiche/common/platform/api/quiche_export.h"
-
-namespace quiche {
-
-// Contains a response to a HTTP POST request issued by BlindSignAuth.
-class QUICHE_EXPORT BlindSignHttpResponse {
- public:
-  BlindSignHttpResponse(int status_code, std::string body)
-      : status_code_(status_code), body_(std::move(body)) {}
-
-  int status_code() const { return status_code_; }
-  const std::string& body() const { return body_; }
-
- private:
-  int status_code_;
-  std::string body_;
-};
-
-}  // namespace quiche
-
-#endif  // QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_HTTP_RESPONSE_H_
diff --git a/quiche/blind_sign_auth/blind_sign_message_interface.h b/quiche/blind_sign_auth/blind_sign_message_interface.h
index 5edad7b..8004a0e 100644
--- a/quiche/blind_sign_auth/blind_sign_message_interface.h
+++ b/quiche/blind_sign_auth/blind_sign_message_interface.h
@@ -10,40 +10,37 @@
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "quiche/blind_sign_auth/blind_sign_http_response.h"
+#include "quiche/blind_sign_auth/blind_sign_message_response.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/quiche_callbacks.h"
 
 namespace quiche {
 
-using BlindSignHttpCallback =
-    quiche::SingleUseCallback<void(absl::StatusOr<BlindSignHttpResponse>)>;
+using BlindSignMessageCallback =
+    quiche::SingleUseCallback<void(absl::StatusOr<BlindSignMessageResponse>)>;
 
-enum class BlindSignHttpRequestType {
+enum class BlindSignMessageRequestType {
   kUnknown = 0,
   kGetInitialData,
   kAuthAndSign,
 };
 
-// Interface for async HTTP POST requests in BlindSignAuth.
-// Implementers must send a request to a signer server's URL
-// and call the provided callback when the request is complete.
+// Interface for async requests in BlindSignAuth. Implementers must send a
+// request and call the provided callback when the request is complete.
 class QUICHE_EXPORT BlindSignMessageInterface {
  public:
   virtual ~BlindSignMessageInterface() = default;
-  // Non-HTTP errors (like failing to create a socket) must return an
-  // absl::Status.
-  // HTTP errors must set status_code and body in BlindSignHttpResponse.
-  // DoRequest must be a HTTP POST request.
+  // Errors must set status_code and body in BlindSignMessageResponse.
+  // DoRequest must either be a HTTP POST or an IPC request.
   // Requests do not need cookies and must follow redirects.
   // The implementer must set Content-Type and Accept headers to
   // "application/x-protobuf".
   // DoRequest is async. When the request completes, the implementer must call
   // the provided callback.
-  virtual void DoRequest(BlindSignHttpRequestType request_type,
+  virtual void DoRequest(BlindSignMessageRequestType request_type,
                          std::optional<absl::string_view> authorization_header,
                          const std::string& body,
-                         BlindSignHttpCallback callback) = 0;
+                         BlindSignMessageCallback callback) = 0;
 };
 
 }  // namespace quiche
diff --git a/quiche/blind_sign_auth/blind_sign_message_response.cc b/quiche/blind_sign_auth/blind_sign_message_response.cc
new file mode 100644
index 0000000..5e7d9ce
--- /dev/null
+++ b/quiche/blind_sign_auth/blind_sign_message_response.cc
@@ -0,0 +1,43 @@
+#include "quiche/blind_sign_auth/blind_sign_message_response.h"
+
+namespace quiche {
+
+absl::StatusCode BlindSignMessageResponse::HttpCodeToStatusCode(int http_code) {
+  // copybara:strip_begin(golink)
+  // This mapping is from go/http-canonical-mapping
+  // copybara:strip_end
+  if (http_code >= 200 && http_code < 300) {
+    return absl::StatusCode::kOk;
+  } else if (http_code >= 300 && http_code < 400) {
+    return absl::StatusCode::kUnknown;
+  } else if (http_code == 400) {
+    return absl::StatusCode::kInvalidArgument;
+  } else if (http_code == 401) {
+    return absl::StatusCode::kUnauthenticated;
+  } else if (http_code == 403) {
+    return absl::StatusCode::kPermissionDenied;
+  } else if (http_code == 404) {
+    return absl::StatusCode::kNotFound;
+  } else if (http_code == 409) {
+    return absl::StatusCode::kAborted;
+  } else if (http_code == 416) {
+    return absl::StatusCode::kOutOfRange;
+  } else if (http_code == 429) {
+    return absl::StatusCode::kResourceExhausted;
+  } else if (http_code == 499) {
+    return absl::StatusCode::kCancelled;
+  } else if (http_code >= 400 && http_code < 500) {
+    return absl::StatusCode::kFailedPrecondition;
+  } else if (http_code == 501) {
+    return absl::StatusCode::kUnimplemented;
+  } else if (http_code == 503) {
+    return absl::StatusCode::kUnavailable;
+  } else if (http_code == 504) {
+    return absl::StatusCode::kDeadlineExceeded;
+  } else if (http_code >= 500 && http_code < 600) {
+    return absl::StatusCode::kInternal;
+  }
+  return absl::StatusCode::kUnknown;
+}
+
+}  // namespace quiche
diff --git a/quiche/blind_sign_auth/blind_sign_message_response.h b/quiche/blind_sign_auth/blind_sign_message_response.h
new file mode 100644
index 0000000..9991477
--- /dev/null
+++ b/quiche/blind_sign_auth/blind_sign_message_response.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_MESSAGE_RESPONSE_H_
+#define QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_MESSAGE_RESPONSE_H_
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace quiche {
+
+// Contains a response to a request issued by BlindSignAuth.
+class QUICHE_EXPORT BlindSignMessageResponse {
+ public:
+  BlindSignMessageResponse(absl::StatusCode status_code, std::string body)
+      : status_code_(status_code), body_(std::move(body)) {}
+
+  absl::StatusCode status_code() const { return status_code_; }
+  const std::string& body() const { return body_; }
+
+  // Converts HTTP code to a StatusCode.
+  static absl::StatusCode HttpCodeToStatusCode(int http_code);
+
+ private:
+  absl::StatusCode status_code_;
+  std::string body_;
+};
+
+}  // namespace quiche
+
+#endif  // QUICHE_BLIND_SIGN_AUTH_BLIND_SIGN_MESSAGE_RESPONSE_H_
diff --git a/quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h b/quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h
similarity index 60%
rename from quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h
rename to quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h
index ae2d2e0..a889d3f 100644
--- a/quiche/blind_sign_auth/test_tools/mock_blind_sign_http_interface.h
+++ b/quiche/blind_sign_auth/test_tools/mock_blind_sign_message_interface.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_HTTP_INTERFACE_H_
-#define QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_HTTP_INTERFACE_H_
+#ifndef QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_MESSAGE_INTERFACE_H_
+#define QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_MESSAGE_INTERFACE_H_
 
 #include <optional>
 #include <string>
@@ -15,16 +15,16 @@
 
 namespace quiche::test {
 
-class QUICHE_NO_EXPORT MockBlindSignHttpInterface
+class QUICHE_NO_EXPORT MockBlindSignMessageInterface
     : public BlindSignMessageInterface {
  public:
   MOCK_METHOD(void, DoRequest,
-              (BlindSignHttpRequestType request_type,
+              (BlindSignMessageRequestType request_type,
                std::optional<absl::string_view> authorization_header,
-               const std::string& body, BlindSignHttpCallback callback),
+               const std::string& body, BlindSignMessageCallback callback),
               (override));
 };
 
 }  // namespace quiche::test
 
-#endif  // QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_HTTP_INTERFACE_H_
+#endif  // QUICHE_BLIND_SIGN_AUTH_TEST_TOOLS_MOCK_BLIND_SIGN_MESSAGE_INTERFACE_H_