diff --git a/keyserver/src/creators/account-creator.js b/keyserver/src/creators/account-creator.js
index 2eb25aa55..b377dd8cc 100644
--- a/keyserver/src/creators/account-creator.js
+++ b/keyserver/src/creators/account-creator.js
@@ -1,196 +1,336 @@
 // @flow
 
 import invariant from 'invariant';
 import bcrypt from 'twin-bcrypt';
 
 import ashoat from 'lib/facts/ashoat';
 import bots from 'lib/facts/bots';
 import genesis from 'lib/facts/genesis';
 import { policyTypes } from 'lib/facts/policies.js';
 import {
   validUsernameRegex,
   oldValidUsernameRegex,
 } from 'lib/shared/account-utils';
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import type {
   RegisterResponse,
   RegisterRequest,
 } from 'lib/types/account-types';
 import { messageTypes } from 'lib/types/message-types';
 import { threadTypes } from 'lib/types/thread-types';
 import { ServerError } from 'lib/utils/errors';
 import { values } from 'lib/utils/objects';
 import { reservedUsernamesSet } from 'lib/utils/reserved-users';
 
 import { dbQuery, SQL } from '../database/database';
 import { deleteCookie } from '../deleters/cookie-deleters';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers';
 import {
   fetchLoggedInUserInfo,
   fetchKnownUserInfos,
 } from '../fetchers/user-fetchers';
 import { verifyCalendarQueryThreadIDs } from '../responders/entry-responders';
 import { createNewUserCookie, setNewSession } from '../session/cookies';
 import { createScriptViewer } from '../session/scripts';
 import type { Viewer } from '../session/viewer';
 import { updateThread } from '../updaters/thread-updaters';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import createIDs from './id-creator';
 import createMessages from './message-creator';
 import {
   createThread,
   createPrivateThread,
   privateThreadDescription,
 } from './thread-creator';
 
 const { commbot } = bots;
 
 const ashoatMessages = [
   'welcome to Comm!',
   'as you inevitably discover bugs, have feature requests, or design ' +
     'suggestions, feel free to message them to me in the app.',
 ];
 
 const privateMessages = [privateThreadDescription];
 
 async function createAccount(
   viewer: Viewer,
   request: RegisterRequest,
 ): Promise<RegisterResponse> {
   if (request.password.trim() === '') {
     throw new ServerError('empty_password');
   }
   const usernameRegex = hasMinCodeVersion(viewer.platformDetails, 69)
     ? validUsernameRegex
     : oldValidUsernameRegex;
   if (request.username.search(usernameRegex) === -1) {
     throw new ServerError('invalid_username');
   }
 
   const usernameQuery = SQL`
     SELECT COUNT(id) AS count
     FROM users
     WHERE LCASE(username) = LCASE(${request.username})
   `;
   const promises = [dbQuery(usernameQuery)];
   const { calendarQuery } = request;
   if (calendarQuery) {
     promises.push(verifyCalendarQueryThreadIDs(calendarQuery));
   }
 
   const [[usernameResult]] = await Promise.all(promises);
   if (reservedUsernamesSet.has(request.username.toLowerCase())) {
     if (hasMinCodeVersion(viewer.platformDetails, 120)) {
       throw new ServerError('username_reserved');
     } else {
       throw new ServerError('username_taken');
     }
   }
   if (usernameResult[0].count !== 0) {
     throw new ServerError('username_taken');
   }
 
   const hash = bcrypt.hashSync(request.password);
   const time = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [id] = await createIDs('users', 1);
   const newUserRow = [id, request.username, hash, time];
   const newUserQuery = SQL`
     INSERT INTO users(id, username, hash, creation_time)
     VALUES ${[newUserRow]}
   `;
   const [userViewerData] = await Promise.all([
     createNewUserCookie(id, {
       platformDetails: request.platformDetails,
       deviceToken,
     }),
     deleteCookie(viewer.cookieID),
     dbQuery(newUserQuery),
   ]);
   viewer.setNewCookie(userViewerData);
 
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, 0);
   }
 
   await Promise.all([
     updateThread(
       createScriptViewer(ashoat.id),
       {
         threadID: genesis.id,
         changes: { newMemberIDs: [id] },
       },
       { forceAddMembers: true, silenceMessages: true, ignorePermissions: true },
     ),
     viewerAcknowledgmentUpdater(viewer, policyTypes.tosAndPrivacyPolicy),
   ]);
 
   const [privateThreadResult, ashoatThreadResult] = await Promise.all([
     createPrivateThread(viewer, request.username),
     createThread(
       viewer,
       {
         type: threadTypes.PERSONAL,
         initialMemberIDs: [ashoat.id],
       },
       { forceAddMembers: true },
     ),
   ]);
   const ashoatThreadID = ashoatThreadResult.newThreadInfo
     ? ashoatThreadResult.newThreadInfo.id
     : ashoatThreadResult.newThreadID;
   const privateThreadID = privateThreadResult.newThreadInfo
     ? privateThreadResult.newThreadInfo.id
     : privateThreadResult.newThreadID;
   invariant(
     ashoatThreadID && privateThreadID,
     'createThread should return either newThreadInfo or newThreadID',
   );
 
   let messageTime = Date.now();
   const ashoatMessageDatas = ashoatMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: ashoatThreadID,
     creatorID: ashoat.id,
     time: messageTime++,
     text: message,
   }));
   const privateMessageDatas = privateMessages.map(message => ({
     type: messageTypes.TEXT,
     threadID: privateThreadID,
     creatorID: commbot.userID,
     time: messageTime++,
     text: message,
   }));
   const messageDatas = [...ashoatMessageDatas, ...privateMessageDatas];
   const [
     messageInfos,
     threadsResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     createMessages(viewer, messageDatas),
     fetchThreadInfos(viewer),
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
   ]);
   const rawMessageInfos = [
     ...ashoatThreadResult.newMessageInfos,
     ...privateThreadResult.newMessageInfos,
     ...messageInfos,
   ];
 
   return {
     id,
     rawMessageInfos,
     currentUserInfo,
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: values(userInfos),
     },
   };
 }
 
-export default createAccount;
+async function createSIWEAccount(
+  viewer: Viewer,
+  request: RegisterRequest,
+): Promise<RegisterResponse> {
+  if (request.password.trim() === '') {
+    throw new ServerError('empty_password');
+  }
+  const usernameRegex = hasMinCodeVersion(viewer.platformDetails, 69)
+    ? validUsernameRegex
+    : oldValidUsernameRegex;
+  if (request.username.search(usernameRegex) === -1) {
+    throw new ServerError('invalid_username');
+  }
+
+  const usernameQuery = SQL`
+    SELECT COUNT(id) AS count
+    FROM users
+    WHERE LCASE(username) = LCASE(${request.username})
+  `;
+  const promises = [dbQuery(usernameQuery)];
+  const { calendarQuery } = request;
+  if (calendarQuery) {
+    promises.push(verifyCalendarQueryThreadIDs(calendarQuery));
+  }
+
+  const [[usernameResult]] = await Promise.all(promises);
+  if (reservedUsernamesSet.has(request.username.toLowerCase())) {
+    if (hasMinCodeVersion(viewer.platformDetails, 120)) {
+      throw new ServerError('username_reserved');
+    } else {
+      throw new ServerError('username_taken');
+    }
+  }
+  if (usernameResult[0].count !== 0) {
+    throw new ServerError('username_taken');
+  }
+
+  const hash = bcrypt.hashSync(request.password);
+  const time = Date.now();
+  const deviceToken = request.deviceTokenUpdateRequest
+    ? request.deviceTokenUpdateRequest.deviceToken
+    : viewer.deviceToken;
+  const [id] = await createIDs('users', 1);
+  const newUserRow = [id, request.username, hash, time];
+  const newUserQuery = SQL`
+    INSERT INTO users(id, username, hash, creation_time)
+    VALUES ${[newUserRow]}
+  `;
+  const [userViewerData] = await Promise.all([
+    createNewUserCookie(id, {
+      platformDetails: request.platformDetails,
+      deviceToken,
+    }),
+    deleteCookie(viewer.cookieID),
+    dbQuery(newUserQuery),
+  ]);
+  viewer.setNewCookie(userViewerData);
+
+  if (calendarQuery) {
+    await setNewSession(viewer, calendarQuery, 0);
+  }
+
+  await Promise.all([
+    updateThread(
+      createScriptViewer(ashoat.id),
+      {
+        threadID: genesis.id,
+        changes: { newMemberIDs: [id] },
+      },
+      { forceAddMembers: true, silenceMessages: true, ignorePermissions: true },
+    ),
+    viewerAcknowledgmentUpdater(viewer, policyTypes.tosAndPrivacyPolicy),
+  ]);
+
+  const [privateThreadResult, ashoatThreadResult] = await Promise.all([
+    createPrivateThread(viewer, request.username),
+    createThread(
+      viewer,
+      {
+        type: threadTypes.PERSONAL,
+        initialMemberIDs: [ashoat.id],
+      },
+      { forceAddMembers: true },
+    ),
+  ]);
+  const ashoatThreadID = ashoatThreadResult.newThreadInfo
+    ? ashoatThreadResult.newThreadInfo.id
+    : ashoatThreadResult.newThreadID;
+  const privateThreadID = privateThreadResult.newThreadInfo
+    ? privateThreadResult.newThreadInfo.id
+    : privateThreadResult.newThreadID;
+  invariant(
+    ashoatThreadID && privateThreadID,
+    'createThread should return either newThreadInfo or newThreadID',
+  );
+
+  let messageTime = Date.now();
+  const ashoatMessageDatas = ashoatMessages.map(message => ({
+    type: messageTypes.TEXT,
+    threadID: ashoatThreadID,
+    creatorID: ashoat.id,
+    time: messageTime++,
+    text: message,
+  }));
+  const privateMessageDatas = privateMessages.map(message => ({
+    type: messageTypes.TEXT,
+    threadID: privateThreadID,
+    creatorID: commbot.userID,
+    time: messageTime++,
+    text: message,
+  }));
+  const messageDatas = [...ashoatMessageDatas, ...privateMessageDatas];
+  const [
+    messageInfos,
+    threadsResult,
+    userInfos,
+    currentUserInfo,
+  ] = await Promise.all([
+    createMessages(viewer, messageDatas),
+    fetchThreadInfos(viewer),
+    fetchKnownUserInfos(viewer),
+    fetchLoggedInUserInfo(viewer),
+  ]);
+  const rawMessageInfos = [
+    ...ashoatThreadResult.newMessageInfos,
+    ...privateThreadResult.newMessageInfos,
+    ...messageInfos,
+  ];
+
+  return {
+    id,
+    rawMessageInfos,
+    currentUserInfo,
+    cookieChange: {
+      threadInfos: threadsResult.threadInfos,
+      userInfos: values(userInfos),
+    },
+  };
+}
+
+export { createAccount, createSIWEAccount };
diff --git a/keyserver/src/responders/user-responders.js b/keyserver/src/responders/user-responders.js
index 2aa846a6a..3fd2dfdf3 100644
--- a/keyserver/src/responders/user-responders.js
+++ b/keyserver/src/responders/user-responders.js
@@ -1,439 +1,439 @@
 // @flow
 
 import invariant from 'invariant';
 import { ErrorTypes, SiweMessage } from 'siwe';
 import t from 'tcomb';
 import bcrypt from 'twin-bcrypt';
 
 import { policies } from 'lib/facts/policies.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils';
 import type {
   ResetPasswordRequest,
   LogOutResponse,
   DeleteAccountRequest,
   RegisterResponse,
   RegisterRequest,
   LogInResponse,
   LogInRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
 } from 'lib/types/account-types';
 import {
   userSettingsTypes,
   notificationTypeValues,
   logInActionSources,
 } from 'lib/types/account-types';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import { defaultNumberPerThread } from 'lib/types/message-types';
 import type { SIWEAuthRequest, SIWEMessage } from 'lib/types/siwe-types.js';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResponse,
 } from 'lib/types/subscription-types';
 import type { PasswordUpdate } from 'lib/types/user-types';
 import { ServerError } from 'lib/utils/errors';
 import { values } from 'lib/utils/objects';
 import { promiseAll } from 'lib/utils/promises';
 import { isValidSIWEMessage } from 'lib/utils/siwe-utils.js';
 import {
   tShape,
   tPlatformDetails,
   tPassword,
   tEmail,
   tOldValidUsername,
 } from 'lib/utils/validation-utils';
 
-import createAccount from '../creators/account-creator';
+import { createAccount } from '../creators/account-creator';
 import { dbQuery, SQL } from '../database/database';
 import { deleteAccount } from '../deleters/account-deleters';
 import { deleteCookie } from '../deleters/cookie-deleters';
 import { checkAndInvalidateSIWENonceEntry } from '../deleters/siwe-nonce-deleters.js';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers';
 import { fetchMessageInfos } from '../fetchers/message-fetchers';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers';
 import {
   fetchKnownUserInfos,
   fetchLoggedInUserInfo,
   fetchUserIDForEthereumAddress,
 } from '../fetchers/user-fetchers';
 import {
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
 } from '../session/cookies';
 import type { Viewer } from '../session/viewer';
 import {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updatePassword,
   updateUserSettings,
 } from '../updaters/account-updaters';
 import { userSubscriptionUpdater } from '../updaters/user-subscription-updaters';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import { validateInput } from '../utils/validation-utils';
 import {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders';
 
 const subscriptionUpdateRequestInputValidator = tShape({
   threadID: t.String,
   updatedFields: tShape({
     pushNotifs: t.maybe(t.Boolean),
     home: t.maybe(t.Boolean),
   }),
 });
 
 async function userSubscriptionUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SubscriptionUpdateResponse> {
   const request: SubscriptionUpdateRequest = input;
   await validateInput(viewer, subscriptionUpdateRequestInputValidator, request);
   const threadSubscription = await userSubscriptionUpdater(viewer, request);
   return { threadSubscription };
 }
 
 const accountUpdateInputValidator = tShape({
   updatedFields: tShape({
     email: t.maybe(tEmail),
     password: t.maybe(tPassword),
   }),
   currentPassword: tPassword,
 });
 
 async function passwordUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: PasswordUpdate = input;
   await validateInput(viewer, accountUpdateInputValidator, request);
   await accountUpdater(viewer, request);
 }
 
 async function sendVerificationEmailResponder(viewer: Viewer): Promise<void> {
   await validateInput(viewer, null, null);
   await checkAndSendVerificationEmail(viewer);
 }
 
 const resetPasswordRequestInputValidator = tShape({
   usernameOrEmail: t.union([tEmail, tOldValidUsername]),
 });
 
 async function sendPasswordResetEmailResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: ResetPasswordRequest = input;
   await validateInput(viewer, resetPasswordRequestInputValidator, request);
   await checkAndSendPasswordResetEmail(request);
 }
 
 async function logOutResponder(viewer: Viewer): Promise<LogOutResponse> {
   await validateInput(viewer, null, null);
   if (viewer.loggedIn) {
     const [anonymousViewerData] = await Promise.all([
       createNewAnonymousCookie({
         platformDetails: viewer.platformDetails,
         deviceToken: viewer.deviceToken,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(anonymousViewerData);
   }
   return {
     currentUserInfo: {
       id: viewer.id,
       anonymous: true,
     },
   };
 }
 
 const deleteAccountRequestInputValidator = tShape({
   password: tPassword,
 });
 
 async function accountDeletionResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogOutResponse> {
   const request: DeleteAccountRequest = input;
   await validateInput(viewer, deleteAccountRequestInputValidator, request);
   const result = await deleteAccount(viewer, request);
   invariant(result, 'deleteAccount should return result if handed request');
   return result;
 }
 
 const deviceTokenUpdateRequestInputValidator = tShape({
   deviceType: t.maybe(t.enums.of(['ios', 'android'])),
   deviceToken: t.String,
 });
 
 const registerRequestInputValidator = tShape({
   username: t.String,
   email: t.maybe(tEmail),
   password: tPassword,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
 });
 
 async function accountCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<RegisterResponse> {
   const request: RegisterRequest = input;
   await validateInput(viewer, registerRequestInputValidator, request);
   return await createAccount(viewer, request);
 }
 
 async function processSuccessfulLogin(
   viewer: Viewer,
   input: any,
   userID: string,
   calendarQuery: ?CalendarQuery,
 ): Promise<LogInResponse> {
   const request: LogInRequest = input;
   const newServerTime = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [userViewerData] = await Promise.all([
     createNewUserCookie(userID, {
       platformDetails: request.platformDetails,
       deviceToken,
     }),
     deleteCookie(viewer.cookieID),
   ]);
   viewer.setNewCookie(userViewerData);
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, newServerTime);
   }
 
   const threadCursors = {};
   for (const watchedThreadID of request.watchedIDs) {
     threadCursors[watchedThreadID] = null;
   }
   const messageSelectionCriteria = { threadCursors, joinedThreads: true };
 
   const [
     threadsResult,
     messagesResult,
     entriesResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     fetchThreadInfos(viewer),
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     calendarQuery ? fetchEntryInfos(viewer, [calendarQuery]) : undefined,
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
   ]);
 
   const rawEntryInfos = entriesResult ? entriesResult.rawEntryInfos : null;
   const response: LogInResponse = {
     currentUserInfo,
     rawMessageInfos: messagesResult.rawMessageInfos,
     truncationStatuses: messagesResult.truncationStatuses,
     serverTime: newServerTime,
     userInfos: values(userInfos),
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: [],
     },
   };
   if (rawEntryInfos) {
     response.rawEntryInfos = rawEntryInfos;
   }
   return response;
 }
 
 const logInRequestInputValidator = tShape({
   username: t.maybe(t.String),
   usernameOrEmail: t.maybe(t.union([tEmail, tOldValidUsername])),
   password: tPassword,
   watchedIDs: t.list(t.String),
   calendarQuery: t.maybe(entryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   source: t.maybe(t.enums.of(values(logInActionSources))),
 });
 
 async function logInResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, logInRequestInputValidator, input);
   const request: LogInRequest = input;
 
   const calendarQuery = request.calendarQuery
     ? normalizeCalendarQuery(request.calendarQuery)
     : null;
   const promises = {};
   if (calendarQuery) {
     promises.verifyCalendarQueryThreadIDs = verifyCalendarQueryThreadIDs(
       calendarQuery,
     );
   }
   const username = request.username ?? request.usernameOrEmail;
   if (!username) {
     throw new ServerError('invalid_parameters');
   }
   const userQuery = SQL`
     SELECT id, hash, username
     FROM users
     WHERE LCASE(username) = LCASE(${username})
   `;
   promises.userQuery = dbQuery(userQuery);
   const {
     userQuery: [userResult],
   } = await promiseAll(promises);
 
   if (userResult.length === 0) {
     throw new ServerError('invalid_parameters');
   }
   const userRow = userResult[0];
   if (!userRow.hash || !bcrypt.compareSync(request.password, userRow.hash)) {
     if (hasMinCodeVersion(viewer.platformDetails, 99999)) {
       throw new ServerError('invalid_parameters');
     } else {
       throw new ServerError('invalid_credentials');
     }
   }
   const id = userRow.id.toString();
   return await processSuccessfulLogin(viewer, input, id, calendarQuery);
 }
 
 const siweAuthRequestInputValidator = tShape({
   signature: t.String,
   message: t.String,
   calendarQuery: t.maybe(entryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   watchedIDs: t.list(t.String),
 });
 
 async function siweAuthResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, siweAuthRequestInputValidator, input);
   const request: SIWEAuthRequest = input;
   const { message, signature } = request;
 
   // 1. Ensure that `message` is a well formed Comm SIWE Auth message.
   const siweMessage: SIWEMessage = new SiweMessage(message);
   if (!isValidSIWEMessage(siweMessage)) {
     throw new ServerError('invalid_parameters');
   }
 
   // 2. Ensure that the `nonce` exists in the `siwe_nonces` table
   //    AND hasn't expired. If those conditions are met, delete the entry to
   //    ensure that the same `nonce` can't be re-used in a future request.
   const wasNonceCheckedAndInvalidated = await checkAndInvalidateSIWENonceEntry(
     siweMessage.nonce,
   );
   if (!wasNonceCheckedAndInvalidated) {
     throw new ServerError('invalid_parameters');
   }
 
   // 3. Validate SIWEMessage signature and handle possible errors.
   try {
     await siweMessage.validate(signature);
   } catch (error) {
     if (error === ErrorTypes.EXPIRED_MESSAGE) {
       // Thrown when the `expirationTime` is present and in the past.
       throw new ServerError('expired_message');
     } else if (error === ErrorTypes.INVALID_SIGNATURE) {
       // Thrown when the `validate()` function can't verify the message.
       throw new ServerError('invalid_signature');
     } else if (error === ErrorTypes.MALFORMED_SESSION) {
       // Thrown when some required field is missing.
       throw new ServerError('malformed_session');
     } else {
       throw new ServerError('unknown_error');
     }
   }
 
   // 4. Complete login with call to `successfulLogInQueries(...)`
   //    if `address` corresponds to an existing user.
   const userID = await fetchUserIDForEthereumAddress(siweMessage.address);
   if (!userID) {
     throw new ServerError('placeholder_error');
   }
   return await processSuccessfulLogin(viewer, input, userID);
 }
 
 const updatePasswordRequestInputValidator = tShape({
   code: t.String,
   password: tPassword,
   watchedIDs: t.list(t.String),
   calendarQuery: t.maybe(entryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
 });
 
 async function oldPasswordUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, updatePasswordRequestInputValidator, input);
   const request: UpdatePasswordRequest = input;
   if (request.calendarQuery) {
     request.calendarQuery = normalizeCalendarQuery(request.calendarQuery);
   }
   return await updatePassword(viewer, request);
 }
 
 const updateUserSettingsInputValidator = tShape({
   name: t.irreducible(
     userSettingsTypes.DEFAULT_NOTIFICATIONS,
     x => x === userSettingsTypes.DEFAULT_NOTIFICATIONS,
   ),
   data: t.enums.of(notificationTypeValues),
 });
 
 async function updateUserSettingsResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: UpdateUserSettingsRequest = input;
   await validateInput(viewer, updateUserSettingsInputValidator, request);
   return await updateUserSettings(viewer, request);
 }
 
 const policyAcknowledgmentRequestInputValidator = tShape({
   policy: t.maybe(t.enums.of(policies)),
 });
 
 async function policyAcknowledgmentResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: PolicyAcknowledgmentRequest = input;
   await validateInput(
     viewer,
     policyAcknowledgmentRequestInputValidator,
     request,
   );
   await viewerAcknowledgmentUpdater(viewer, request.policy);
 }
 
 export {
   userSubscriptionUpdateResponder,
   passwordUpdateResponder,
   sendVerificationEmailResponder,
   sendPasswordResetEmailResponder,
   logOutResponder,
   accountDeletionResponder,
   accountCreationResponder,
   logInResponder,
   siweAuthResponder,
   oldPasswordUpdateResponder,
   updateUserSettingsResponder,
   policyAcknowledgmentResponder,
 };