Add support for generating discriminators

- adds `PUT accounts/username` endpoint
- adds `GET accounts/username/{username}` to lookup aci by username
- deletes `PUT accounts/username/{username}`, `GET profile/username/{username}`
- adds randomized discriminator generation

service/src/main/java/org/whispersystems/textsecuregcm/WhisperServerConfiguration.java

@@ -45,6 +45,7 @@ import org.whispersystems.textsecuregcm.configuration.SubscriptionConfiguration;
 import org.whispersystems.textsecuregcm.configuration.TestDeviceConfiguration;
 import org.whispersystems.textsecuregcm.configuration.TwilioConfiguration;
 import org.whispersystems.textsecuregcm.configuration.UnidentifiedDeliveryConfiguration;
+import org.whispersystems.textsecuregcm.configuration.UsernameConfiguration;
 import org.whispersystems.textsecuregcm.configuration.VoiceVerificationConfiguration;
 import org.whispersystems.textsecuregcm.configuration.ZkConfig;
 import org.whispersystems.websocket.configuration.WebSocketConfiguration;
@@ -247,6 +248,11 @@ public class WhisperServerConfiguration extends Configuration {
   @JsonProperty
   private ReportMessageConfiguration reportMessage = new ReportMessageConfiguration();
 
+  @Valid
+  @NotNull
+  @JsonProperty
+  private UsernameConfiguration username = new UsernameConfiguration();
+
   @Valid
   @JsonProperty
   private AbusiveMessageFilterConfiguration abusiveMessageFilter;
@@ -424,4 +430,8 @@ public class WhisperServerConfiguration extends Configuration {
   public AbusiveMessageFilterConfiguration getAbusiveMessageFilterConfiguration() {
     return abusiveMessageFilter;
   }
+
+  public UsernameConfiguration getUsername() {
+    return username;
+  }
 }

service/src/main/java/org/whispersystems/textsecuregcm/WhisperServerService.java

@@ -205,6 +205,7 @@ import org.whispersystems.textsecuregcm.stripe.StripeManager;
 import org.whispersystems.textsecuregcm.util.Constants;
 import org.whispersystems.textsecuregcm.util.DynamoDbFromConfig;
 import org.whispersystems.textsecuregcm.util.HostnameUtil;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import org.whispersystems.textsecuregcm.util.logging.LoggingUnhandledExceptionMapper;
 import org.whispersystems.textsecuregcm.util.logging.UncaughtExceptionHandler;
 import org.whispersystems.textsecuregcm.websocket.AuthenticatedConnectListener;
@@ -444,11 +445,13 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
     PushLatencyManager         pushLatencyManager         = new PushLatencyManager(metricsCluster, dynamicConfigurationManager);
     ReportMessageManager       reportMessageManager       = new ReportMessageManager(reportMessageDynamoDb, rateLimitersCluster, config.getReportMessageConfiguration().getCounterTtl());
     MessagesManager            messagesManager            = new MessagesManager(messagesDynamoDb, messagesCache, reportMessageManager);
+    UsernameGenerator          usernameGenerator          = new UsernameGenerator(config.getUsername());
     DeletedAccountsManager deletedAccountsManager = new DeletedAccountsManager(deletedAccounts,
         deletedAccountsLockDynamoDbClient, config.getDynamoDbTables().getDeletedAccountsLock().getTableName());
     AccountsManager accountsManager = new AccountsManager(accounts, phoneNumberIdentifiers, cacheCluster,
         deletedAccountsManager, directoryQueue, keys, messagesManager, reservedUsernames, profilesManager,
-        pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, clock);
+        pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, usernameGenerator,
+        experimentEnrollmentManager, clock);
     RemoteConfigsManager       remoteConfigsManager       = new RemoteConfigsManager(remoteConfigs);
     DispatchManager            dispatchManager            = new DispatchManager(pubSubClientFactory, Optional.empty());
     PubSubManager              pubSubManager              = new PubSubManager(pubsubClient, dispatchManager);

service/src/main/java/org/whispersystems/textsecuregcm/configuration/UsernameConfiguration.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013-2020 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.configuration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import javax.validation.constraints.Min;
+
+public class UsernameConfiguration {
+
+  @JsonProperty
+  @Min(1)
+  private int discriminatorInitialWidth = 4;
+
+  @JsonProperty
+  @Min(1)
+  private int discriminatorMaxWidth = 9;
+
+  @JsonProperty
+  @Min(1)
+  private int attemptsPerWidth = 10;
+
+  public int getDiscriminatorInitialWidth() {
+    return discriminatorInitialWidth;
+  }
+
+  public int getDiscriminatorMaxWidth() {
+    return discriminatorMaxWidth;
+  }
+
+  public int getAttemptsPerWidth() {
+    return attemptsPerWidth;
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/controllers/AccountController.java

@@ -64,6 +64,7 @@ import org.whispersystems.textsecuregcm.auth.TurnTokenGenerator;
 import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicCaptchaConfiguration;
 import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicConfiguration;
 import org.whispersystems.textsecuregcm.entities.AccountAttributes;
+import org.whispersystems.textsecuregcm.entities.AccountIdentifierResponse;
 import org.whispersystems.textsecuregcm.entities.AccountIdentityResponse;
 import org.whispersystems.textsecuregcm.entities.ApnRegistrationId;
 import org.whispersystems.textsecuregcm.entities.ChangePhoneNumberRequest;
@@ -73,6 +74,9 @@ import org.whispersystems.textsecuregcm.entities.MismatchedDevices;
 import org.whispersystems.textsecuregcm.entities.RegistrationLock;
 import org.whispersystems.textsecuregcm.entities.RegistrationLockFailure;
 import org.whispersystems.textsecuregcm.entities.StaleDevices;
+import org.whispersystems.textsecuregcm.entities.UsernameRequest;
+import org.whispersystems.textsecuregcm.entities.UsernameResponse;
+import org.whispersystems.textsecuregcm.limits.RateLimiter;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
 import org.whispersystems.textsecuregcm.metrics.UserAgentTagUtil;
 import org.whispersystems.textsecuregcm.push.PushNotification;
@@ -93,7 +97,7 @@ import org.whispersystems.textsecuregcm.util.ForwardedIpUtil;
 import org.whispersystems.textsecuregcm.util.Hex;
 import org.whispersystems.textsecuregcm.util.ImpossiblePhoneNumberException;
 import org.whispersystems.textsecuregcm.util.NonNormalizedPhoneNumberException;
-import org.whispersystems.textsecuregcm.util.Username;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import org.whispersystems.textsecuregcm.util.Util;
 import org.whispersystems.textsecuregcm.util.VerificationCode;
 
@@ -119,6 +123,7 @@ public class AccountController {
   private static final String TWILIO_VERIFY_ERROR_COUNTER_NAME = name(AccountController.class, "twilioVerifyError");
 
   private static final String INVALID_ACCEPT_LANGUAGE_COUNTER_NAME = name(AccountController.class, "invalidAcceptLanguage");
+  private static final String NONSTANDARD_USERNAME_COUNTER_NAME = name(AccountController.class, "nonStandardUsername");
 
   private static final String CHALLENGE_PRESENT_TAG_NAME = "present";
   private static final String CHALLENGE_MATCH_TAG_NAME = "matches";
@@ -127,6 +132,7 @@ public class AccountController {
 
   private static final String VERIFY_EXPERIMENT_TAG_NAME = "twilioVerify";
 
+
   private final StoredVerificationCodeManager      pendingAccounts;
   private final AccountsManager                    accounts;
   private final AbusiveHostRules                   abusiveHostRules;
@@ -628,6 +634,7 @@ public class AccountController {
         auth.getAccount().isStorageSupported());
   }
 
+  @Timed
   @DELETE
   @Path("/username")
   @Produces(MediaType.APPLICATION_JSON)
@@ -635,20 +642,66 @@ public class AccountController {
     accounts.clearUsername(auth.getAccount());
   }
 
+  @Timed
   @PUT
-  @Path("/username/{username}")
+  @Path("/username")
   @Produces(MediaType.APPLICATION_JSON)
-  public Response setUsername(@Auth AuthenticatedAccount auth, @PathParam("username") @Username String username)
-      throws RateLimitExceededException {
+  @Consumes(MediaType.APPLICATION_JSON)
+  public UsernameResponse setUsername(
+      @Auth AuthenticatedAccount auth,
+      @HeaderParam("X-Signal-Agent") String userAgent,
+      @NotNull @Valid UsernameRequest usernameRequest) throws RateLimitExceededException {
     rateLimiters.getUsernameSetLimiter().validate(auth.getAccount().getUuid());
 
-    try {
-      accounts.setUsername(auth.getAccount(), username);
-    } catch (final UsernameNotAvailableException e) {
-      return Response.status(Response.Status.CONFLICT).build();
+    if (StringUtils.isNotBlank(usernameRequest.existingUsername()) &&
+        !UsernameGenerator.isStandardFormat(usernameRequest.existingUsername())) {
+      // Technically, a username may not be in the nickname#discriminator format
+      // if created through some out-of-band mechanism, but it is atypical.
+      Metrics.counter(NONSTANDARD_USERNAME_COUNTER_NAME, Tags.of(UserAgentTagUtil.getPlatformTag(userAgent)))
+          .increment();
     }
 
-    return Response.ok().build();
+    try {
+      final Account account = accounts.setUsername(auth.getAccount(), usernameRequest.nickname(),
+          usernameRequest.existingUsername());
+      return account
+          .getUsername()
+          .map(UsernameResponse::new)
+          .orElseThrow(() -> new IllegalStateException("Could not get username after setting"));
+    } catch (final UsernameNotAvailableException e) {
+      throw new WebApplicationException(Status.CONFLICT);
+    }
+  }
+
+  @Timed
+  @GET
+  @Path("/username/{username}")
+  @Produces(MediaType.APPLICATION_JSON)
+  public AccountIdentifierResponse lookupUsername(
+      @HeaderParam("X-Signal-Agent") final String userAgent,
+      @HeaderParam("X-Forwarded-For") final String forwardedFor,
+      @PathParam("username") final String username,
+      @Context final HttpServletRequest request) throws RateLimitExceededException {
+
+    // Disallow clients from making authenticated requests to this endpoint
+    if (StringUtils.isNotBlank(request.getHeader("Authorization"))) {
+      throw new BadRequestException();
+    }
+
+    if (!UsernameGenerator.isStandardFormat(username)) {
+      // Technically, a username may not be in the nickname#discriminator format
+      // if created through some out-of-band mechanism, but it is atypical.
+      Metrics.counter(NONSTANDARD_USERNAME_COUNTER_NAME, Tags.of(UserAgentTagUtil.getPlatformTag(userAgent)))
+          .increment();
+    }
+
+    rateLimitByClientIp(rateLimiters.getUsernameLookupLimiter(), forwardedFor);
+
+    return accounts
+        .getByUsername(username)
+        .map(Account::getUuid)
+        .map(AccountIdentifierResponse::new)
+        .orElseThrow(() -> new WebApplicationException(Status.NOT_FOUND));
   }
 
   @HEAD
@@ -662,17 +715,7 @@ public class AccountController {
     if (StringUtils.isNotBlank(request.getHeader("Authorization"))) {
       throw new BadRequestException();
     }
-
-    final String mostRecentProxy = ForwardedIpUtil.getMostRecentProxy(forwardedFor)
-        .orElseThrow(() -> {
-          // Missing/malformed Forwarded-For, so we cannot check for a rate-limit.
-          // This shouldn't happen, so conservatively assume we're over the rate-limit
-          // and indicate that the client should retry
-          logger.error("Missing/bad Forwarded-For, cannot check account {}", uuid.toString());
-          return new RateLimitExceededException(Duration.ofHours(1));
-        });
-
-    rateLimiters.getCheckAccountExistenceLimiter().validate(mostRecentProxy);
+    rateLimitByClientIp(rateLimiters.getCheckAccountExistenceLimiter(), forwardedFor);
 
     final Status status = accounts.getByAccountIdentifier(uuid)
         .or(() -> accounts.getByPhoneNumberIdentifier(uuid))
@@ -681,6 +724,19 @@ public class AccountController {
     return Response.status(status).build();
   }
 
+  private void rateLimitByClientIp(final RateLimiter rateLimiter, final String forwardedFor) throws RateLimitExceededException {
+    final String mostRecentProxy = ForwardedIpUtil.getMostRecentProxy(forwardedFor)
+        .orElseThrow(() -> {
+          // Missing/malformed Forwarded-For, so we cannot check for a rate-limit.
+          // This shouldn't happen, so conservatively assume we're over the rate-limit
+          // and indicate that the client should retry
+          logger.error("Missing/bad Forwarded-For: {}", forwardedFor);
+          return new RateLimitExceededException(Duration.ofHours(1));
+        });
+
+    rateLimiter.validate(mostRecentProxy);
+  }
+
   private void verifyRegistrationLock(final Account existingAccount, @Nullable final String clientRegistrationLock)
       throws RateLimitExceededException, WebApplicationException {
 

service/src/main/java/org/whispersystems/textsecuregcm/controllers/ProfileController.java

@@ -503,24 +503,6 @@ public class ProfileController {
         account.getPhoneNumberIdentifier());
   }
 
-  @Timed
-  @GET
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/username/{username}")
-  public BaseProfileResponse getProfileByUsername(
-      @Auth AuthenticatedAccount auth,
-      @Context ContainerRequestContext containerRequestContext,
-      @PathParam("username") String username)
-      throws RateLimitExceededException {
-
-    rateLimiters.getUsernameLookupLimiter().validate(auth.getAccount().getUuid());
-
-    final Account targetAccount = accountsManager.getByUsername(username).orElseThrow(NotFoundException::new);
-    final boolean isSelf = auth.getAccount().getUuid().equals(targetAccount.getUuid());
-
-    return buildBaseProfileResponseForAccountIdentity(targetAccount, isSelf, containerRequestContext);
-  }
-
   private ProfileKeyCredentialResponse getProfileCredential(final String encodedProfileCredentialRequest,
       final VersionedProfile profile,
       final UUID uuid) {

service/src/main/java/org/whispersystems/textsecuregcm/entities/AccountIdentifierResponse.java

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2022 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.entities;
+import javax.validation.constraints.NotNull;
+import java.util.UUID;
+
+public record AccountIdentifierResponse(@NotNull UUID uuid) {}

service/src/main/java/org/whispersystems/textsecuregcm/entities/UsernameRequest.java

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2022 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.entities;
+
+import org.whispersystems.textsecuregcm.util.Nickname;
+import javax.annotation.Nullable;
+import javax.validation.Valid;
+
+public record UsernameRequest(@Valid @Nickname String nickname, @Nullable String existingUsername) {}

service/src/main/java/org/whispersystems/textsecuregcm/entities/UsernameResponse.java

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2022 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.entities;
+
+public record UsernameResponse(String username) {}

service/src/main/java/org/whispersystems/textsecuregcm/storage/Accounts.java

@@ -345,8 +345,15 @@ public class Accounts extends AbstractDynamoDbStore {
     });
   }
 
+  /**
+   * Set the account username
+   *
+   * @param account to update
+   * @param username believed to be available
+   * @throws ContestedOptimisticLockException if the account has been updated or the username taken by someone else
+   */
   public void setUsername(final Account account, final String username)
-      throws ContestedOptimisticLockException, UsernameNotAvailableException {
+      throws ContestedOptimisticLockException {
     final long startNanos = System.nanoTime();
 
     final Optional<String> maybeOriginalUsername = account.getUsername();
@@ -405,18 +412,14 @@ public class Accounts extends AbstractDynamoDbStore {
     } catch (final JsonProcessingException e) {
       throw new IllegalArgumentException(e);
     } catch (final TransactionCanceledException e) {
-      if ("ConditionalCheckFailed".equals(e.cancellationReasons().get(0).code())) {
-        throw new UsernameNotAvailableException();
-      } else if ("ConditionalCheckFailed".equals(e.cancellationReasons().get(1).code())) {
+      if (e.cancellationReasons().stream().map(CancellationReason::code).anyMatch("ConditionalCheckFailed"::equals)) {
         throw new ContestedOptimisticLockException();
       }
-
       throw e;
     } finally {
       if (!succeeded) {
         account.setUsername(maybeOriginalUsername.orElse(null));
       }
-
       SET_USERNAME_TIMER.record(System.nanoTime() - startNanos, TimeUnit.NANOSECONDS);
     }
   }
@@ -563,6 +566,14 @@ public class Accounts extends AbstractDynamoDbStore {
     }
   }
 
+  public boolean usernameAvailable(final String username) {
+    final GetItemResponse response = client.getItem(GetItemRequest.builder()
+        .tableName(usernamesConstraintTableName)
+        .key(Map.of(ATTR_USERNAME, AttributeValues.fromString(username)))
+        .build());
+    return !response.hasItem();
+  }
+
   public Optional<Account> getByE164(String number) {
     return GET_BY_NUMBER_TIMER.record(() -> {
 

service/src/main/java/org/whispersystems/textsecuregcm/storage/AccountsManager.java

@@ -12,6 +12,7 @@ import com.codahale.metrics.SharedMetricRegistries;
 import com.codahale.metrics.Timer;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
 import io.lettuce.core.RedisException;
 import io.lettuce.core.cluster.api.sync.RedisAdvancedClusterCommands;
 import io.micrometer.core.instrument.Metrics;
@@ -37,6 +38,7 @@ import org.whispersystems.textsecuregcm.auth.AuthenticationCredentials;
 import org.whispersystems.textsecuregcm.controllers.MismatchedDevicesException;
 import org.whispersystems.textsecuregcm.entities.AccountAttributes;
 import org.whispersystems.textsecuregcm.entities.SignedPreKey;
+import org.whispersystems.textsecuregcm.experiment.ExperimentEnrollmentManager;
 import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisCluster;
 import org.whispersystems.textsecuregcm.redis.RedisOperation;
@@ -46,7 +48,7 @@ import org.whispersystems.textsecuregcm.sqs.DirectoryQueue;
 import org.whispersystems.textsecuregcm.util.Constants;
 import org.whispersystems.textsecuregcm.util.DestinationDeviceValidator;
 import org.whispersystems.textsecuregcm.util.SystemMapper;
-import org.whispersystems.textsecuregcm.util.UsernameValidator;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import org.whispersystems.textsecuregcm.util.Util;
 
 public class AccountsManager {
@@ -71,6 +73,9 @@ public class AccountsManager {
   private static final String COUNTRY_CODE_TAG_NAME     = "country";
   private static final String DELETION_REASON_TAG_NAME  = "reason";
 
+  @VisibleForTesting
+  public static final String USERNAME_EXPERIMENT_NAME  = "usernames";
+
   private final Logger logger = LoggerFactory.getLogger(AccountsManager.class);
 
   private final Accounts accounts;
@@ -86,7 +91,9 @@ public class AccountsManager {
   private final SecureStorageClient secureStorageClient;
   private final SecureBackupClient secureBackupClient;
   private final ClientPresenceManager clientPresenceManager;
+  private final ExperimentEnrollmentManager experimentEnrollmentManager;
   private final Clock clock;
+  private final UsernameGenerator usernameGenerator;
 
   private static final ObjectMapper mapper = SystemMapper.getMapper();
 
@@ -126,6 +133,8 @@ public class AccountsManager {
       final SecureStorageClient secureStorageClient,
       final SecureBackupClient secureBackupClient,
       final ClientPresenceManager clientPresenceManager,
+      final UsernameGenerator usernameGenerator,
+      final ExperimentEnrollmentManager experimentEnrollmentManager,
       final Clock clock) {
     this.accounts = accounts;
     this.phoneNumberIdentifiers = phoneNumberIdentifiers;
@@ -140,6 +149,8 @@ public class AccountsManager {
     this.secureBackupClient  = secureBackupClient;
     this.clientPresenceManager = clientPresenceManager;
     this.reservedUsernames = reservedUsernames;
+    this.usernameGenerator = usernameGenerator;
+    this.experimentEnrollmentManager = experimentEnrollmentManager;
     this.clock = Objects.requireNonNull(clock);
   }
 
@@ -276,32 +287,27 @@ public class AccountsManager {
 
       final Account numberChangedAccount;
 
-      try {
-        numberChangedAccount = updateWithRetries(
-            account,
-            a -> {
-              //noinspection ConstantConditions
-              if (pniSignedPreKeys != null && pniRegistrationIds != null) {
-                pniSignedPreKeys.forEach((deviceId, signedPreKey) ->
-                    a.getDevice(deviceId).ifPresent(device -> device.setPhoneNumberIdentitySignedPreKey(signedPreKey)));
+      numberChangedAccount = updateWithRetries(
+          account,
+          a -> {
+            //noinspection ConstantConditions
+            if (pniSignedPreKeys != null && pniRegistrationIds != null) {
+              pniSignedPreKeys.forEach((deviceId, signedPreKey) ->
+                  a.getDevice(deviceId).ifPresent(device -> device.setPhoneNumberIdentitySignedPreKey(signedPreKey)));
 
-                pniRegistrationIds.forEach((deviceId, registrationId) ->
-                    a.getDevice(deviceId).ifPresent(device -> device.setPhoneNumberIdentityRegistrationId(registrationId)));
-              }
+              pniRegistrationIds.forEach((deviceId, registrationId) ->
+                  a.getDevice(deviceId).ifPresent(device -> device.setPhoneNumberIdentityRegistrationId(registrationId)));
+            }
 
-              if (pniIdentityKey != null) {
-                a.setPhoneNumberIdentityKey(pniIdentityKey);
-              }
+            if (pniIdentityKey != null) {
+              a.setPhoneNumberIdentityKey(pniIdentityKey);
+            }
 
-              return true;
-            },
-            a -> accounts.changeNumber(a, number, phoneNumberIdentifier),
-            () -> accounts.getByAccountIdentifier(uuid).orElseThrow(),
-            AccountChangeValidator.NUMBER_CHANGE_VALIDATOR);
-      } catch (UsernameNotAvailableException e) {
-        // This should never happen when changing numbers
-        throw new RuntimeException(e);
-      }
+            return true;
+          },
+          a -> accounts.changeNumber(a, number, phoneNumberIdentifier),
+          () -> accounts.getByAccountIdentifier(uuid).orElseThrow(),
+          AccountChangeValidator.NUMBER_CHANGE_VALIDATOR);
 
       updatedAccount.set(numberChangedAccount);
       directoryQueue.changePhoneNumber(numberChangedAccount, originalNumber, number);
@@ -315,23 +321,31 @@ public class AccountsManager {
     return updatedAccount.get();
   }
 
-  public Account setUsername(final Account account, final String username) throws UsernameNotAvailableException {
-    final String canonicalUsername = UsernameValidator.getCanonicalUsername(username);
-
-    if (account.getUsername().map(canonicalUsername::equals).orElse(false)) {
-      return account;
+  public Account setUsername(final Account account, final String requestedNickname, final @Nullable String expectedOldUsername) throws UsernameNotAvailableException {
+    if (!experimentEnrollmentManager.isEnrolled(account.getUuid(), USERNAME_EXPERIMENT_NAME)) {
+      throw new UsernameNotAvailableException();
     }
 
-    if (reservedUsernames.isReserved(canonicalUsername, account.getUuid())) {
+    if (reservedUsernames.isReserved(requestedNickname, account.getUuid())) {
       throw new UsernameNotAvailableException();
     }
 
+    final Optional<String> currentUsername = account.getUsername();
+    final Optional<String> currentNickname = currentUsername.map(UsernameGenerator::extractNickname);
+    if (currentNickname.map(requestedNickname::equals).orElse(false) && !Objects.equals(expectedOldUsername, currentUsername.orElse(null))) {
+      // The requested nickname matches what the server already has, and the
+      // client provided the wrong existing username. Treat this as a replayed
+      // request, assuming that the client has previously succeeded
+      return account;
+    }
+
     redisDelete(account);
 
-    return updateWithRetries(
+    return failableUpdateWithRetries(
         account,
         a -> true,
-        a -> accounts.setUsername(a, canonicalUsername),
+        // In the future, this may also check for any forbidden discriminators
+        a -> accounts.setUsername(a, usernameGenerator.generateAvailableUsername(requestedNickname, accounts::usernameAvailable)),
         () -> accounts.getByAccountIdentifier(account.getUuid()).orElseThrow(),
         AccountChangeValidator.USERNAME_CHANGE_VALIDATOR);
   }
@@ -339,31 +353,20 @@ public class AccountsManager {
   public Account clearUsername(final Account account) {
     redisDelete(account);
 
-    try {
-      return updateWithRetries(
-          account,
-          a -> true,
-          accounts::clearUsername,
-          () -> accounts.getByAccountIdentifier(account.getUuid()).orElseThrow(),
-          AccountChangeValidator.USERNAME_CHANGE_VALIDATOR);
-    } catch (UsernameNotAvailableException e) {
-      // This should never happen
-      throw new RuntimeException(e);
-    }
+    return updateWithRetries(
+        account,
+        a -> true,
+        accounts::clearUsername,
+        () -> accounts.getByAccountIdentifier(account.getUuid()).orElseThrow(),
+        AccountChangeValidator.USERNAME_CHANGE_VALIDATOR);
   }
 
   public Account update(Account account, Consumer<Account> updater) {
-
-    try {
-      return update(account, a -> {
-        updater.accept(a);
-        // assume that all updaters passed to the public method actually modify the account
-        return true;
-      });
-    } catch (UsernameNotAvailableException e) {
-      // This should never happen for general-purpose, public account updates
-      throw new RuntimeException(e);
-    }
+    return update(account, a -> {
+      updater.accept(a);
+      // assume that all updaters passed to the public method actually modify the account
+      return true;
+    });
   }
 
   /**
@@ -371,34 +374,28 @@ public class AccountsManager {
    * redundant updates of {@code device.lastSeen}
    */
   public Account updateDeviceLastSeen(Account account, Device device, final long lastSeen) {
+    return update(account, a -> {
 
-    try {
-      return update(account, a -> {
+      final Optional<Device> maybeDevice = a.getDevice(device.getId());
 
-        final Optional<Device> maybeDevice = a.getDevice(device.getId());
+      return maybeDevice.map(d -> {
+        if (d.getLastSeen() >= lastSeen) {
+          return false;
+        }
 
-        return maybeDevice.map(d -> {
-          if (d.getLastSeen() >= lastSeen) {
-            return false;
-          }
+        d.setLastSeen(lastSeen);
 
-          d.setLastSeen(lastSeen);
+        return true;
 
-          return true;
-
-        }).orElse(false);
-      });
-    } catch (UsernameNotAvailableException e) {
-      // This should never happen when updating last-seen timestamps
-      throw new RuntimeException(e);
-    }
+      }).orElse(false);
+    });
   }
 
   /**
    * @param account account to update
    * @param updater must return {@code true} if the account was actually updated
    */
-  private Account update(Account account, Function<Account, Boolean> updater) throws UsernameNotAvailableException {
+  private Account update(Account account, Function<Account, Boolean> updater) {
 
     final boolean wasVisibleBeforeUpdate = account.shouldBeVisibleInDirectory();
 
@@ -429,6 +426,19 @@ public class AccountsManager {
   }
 
   private Account updateWithRetries(Account account,
+      final Function<Account, Boolean> updater,
+      final Consumer<Account> persister,
+      final Supplier<Account> retriever,
+      final AccountChangeValidator changeValidator) {
+    try {
+      return failableUpdateWithRetries(account, updater, persister::accept, retriever, changeValidator);
+    } catch (UsernameNotAvailableException e) {
+      // not possible
+      throw new IllegalStateException(e);
+    }
+  }
+
+  private Account failableUpdateWithRetries(Account account,
       final Function<Account, Boolean> updater,
       final AccountPersister persister,
       final Supplier<Account> retriever,
@@ -482,16 +492,11 @@ public class AccountsManager {
   }
 
   public Account updateDevice(Account account, long deviceId, Consumer<Device> deviceUpdater) {
-    try {
-      return update(account, a -> {
-        a.getDevice(deviceId).ifPresent(deviceUpdater);
-        // assume that all updaters passed to the public method actually modify the device
-        return true;
-      });
-    } catch (UsernameNotAvailableException e) {
-      // This should never happen when updating devices
-      throw new RuntimeException(e);
-    }
+    return update(account, a -> {
+      a.getDevice(deviceId).ifPresent(deviceUpdater);
+      // assume that all updaters passed to the public method actually modify the device
+      return true;
+    });
   }
 
   public Optional<Account> getByE164(String number) {
@@ -522,12 +527,10 @@ public class AccountsManager {
 
   public Optional<Account> getByUsername(final String username) {
     try (final Timer.Context ignored = getByUsernameTimer.time()) {
-      final String canonicalUsername = UsernameValidator.getCanonicalUsername(username);
-
-      Optional<Account> account = redisGetByUsername(canonicalUsername);
+      Optional<Account> account = redisGetByUsername(username);
 
       if (account.isEmpty()) {
-        account = accounts.getByUsername(canonicalUsername);
+        account = accounts.getByUsername(username);
         account.ifPresent(this::redisSet);
       }
 

service/src/main/java/org/whispersystems/textsecuregcm/storage/ReservedUsernames.java

@@ -53,7 +53,7 @@ public class ReservedUsernames {
     this.tableName = tableName;
   }
 
-  public boolean isReserved(final String username, final UUID accountIdentifier) {
+  public boolean isReserved(final String nickname, final UUID accountIdentifier) {
     return IS_RESERVED_TIMER.record(() -> {
       final ScanIterable scanIterable = dynamoDbClient.scanPaginator(ScanRequest.builder()
           .tableName(tableName)
@@ -66,7 +66,7 @@ public class ReservedUsernames {
               final Pattern pattern = patternCache.get(item.get(KEY_PATTERN).s());
               final UUID reservedFor = AttributeValues.getUUID(item, ATTR_RESERVED_FOR_UUID, null);
 
-              if (pattern.matcher(username).matches() && !accountIdentifier.equals(reservedFor)) {
+              if (pattern.matcher(nickname).matches() && !accountIdentifier.equals(reservedFor)) {
                 return true;
               }
             } catch (final Exception e) {

service/src/main/java/org/whispersystems/textsecuregcm/util/Nickname.java

@@ -5,21 +5,21 @@
 
 package org.whispersystems.textsecuregcm.util;
 
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.PARAMETER;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
-import java.lang.annotation.Retention;
-import java.lang.annotation.Target;
-import javax.validation.Constraint;
-import javax.validation.Payload;
-
 @Target({ FIELD, PARAMETER })
 @Retention(RUNTIME)
-@Constraint(validatedBy = UsernameValidator.class)
-public @interface Username {
+@Constraint(validatedBy = NicknameValidator.class)
+public @interface Nickname {
 
-  String message() default "{org.whispersystems.textsecuregcm.util.Username.message}";
+  String message() default "{org.whispersystems.textsecuregcm.util.Nickname.message}";
 
   Class<?>[] groups() default { };
 

service/src/main/java/org/whispersystems/textsecuregcm/util/NicknameValidator.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2013-2021 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.util;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+
+public class NicknameValidator implements ConstraintValidator<Nickname, String> {
+  @Override
+  public boolean isValid(final String nickname, final ConstraintValidatorContext context) {
+    return UsernameGenerator.isValidNickname(nickname);
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/UsernameGenerator.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2022 Signal Messenger, LLC
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+package org.whispersystems.textsecuregcm.util;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.math.IntMath;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.DistributionSummary;
+import io.micrometer.core.instrument.Metrics;
+import org.apache.commons.lang3.StringUtils;
+import org.whispersystems.textsecuregcm.configuration.UsernameConfiguration;
+import org.whispersystems.textsecuregcm.storage.UsernameNotAvailableException;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+import static org.whispersystems.textsecuregcm.metrics.MetricsUtil.name;
+
+public class UsernameGenerator {
+  /**
+   * Nicknames are
+   * <list>
+   *   <li> lowercase </li>
+   *   <li> do not start with a number </li>
+   *   <li> alphanumeric or underscores only </li>
+   *   <li> minimum length 3 </li>
+   *   <li> maximum length 32 </li>
+   * </list>
+   *
+   * Usernames typically consist of a nickname and an integer discriminator
+   */
+  public static final Pattern NICKNAME_PATTERN = Pattern.compile("^[_a-z][_a-z0-9]{2,31}$");
+  public static final String SEPARATOR = "#";
+
+  private static final Counter USERNAME_NOT_AVAILABLE_COUNTER = Metrics.counter(name(UsernameGenerator.class, "usernameNotAvailable"));
+  private static final DistributionSummary DISCRIMINATOR_ATTEMPT_COUNTER = Metrics.summary(name(UsernameGenerator.class, "discriminatorAttempts"));
+
+  private final int initialWidth;
+  private final int discriminatorMaxWidth;
+  private final int attemptsPerWidth;
+
+  public UsernameGenerator(UsernameConfiguration configuration) {
+    this(configuration.getDiscriminatorInitialWidth(), configuration.getDiscriminatorMaxWidth(), configuration.getAttemptsPerWidth());
+  }
+
+  @VisibleForTesting
+  public UsernameGenerator(int initialWidth, int discriminatorMaxWidth, int attemptsPerWidth) {
+    this.initialWidth = initialWidth;
+    this.discriminatorMaxWidth = discriminatorMaxWidth;
+    this.attemptsPerWidth = attemptsPerWidth;
+  }
+
+  /**
+   * Generate a username with a random discriminator
+   *
+   * @param nickname The string nickname
+   * @param usernameAvailableFun A {@link Predicate} that returns true if the provided username is available
+   * @return The nickname appended with a random discriminator
+   * @throws UsernameNotAvailableException if we failed to find a nickname+discriminator pair that was available
+   */
+  public String generateAvailableUsername(final String nickname, final Predicate<String> usernameAvailableFun) throws UsernameNotAvailableException {
+    int rangeMin = 1;
+    int rangeMax = IntMath.pow(10, initialWidth);
+    int totalMax = IntMath.pow(10, discriminatorMaxWidth);
+    int attempts = 0;
+    while (rangeMax <= totalMax) {
+      // check discriminators of the current width up to attemptsPerWidth times
+      for (int i = 0; i < attemptsPerWidth; i++) {
+        int discriminator = ThreadLocalRandom.current().nextInt(rangeMin, rangeMax);
+        String username = UsernameGenerator.fromParts(nickname, discriminator);
+        attempts++;
+        if (usernameAvailableFun.test(username)) {
+          DISCRIMINATOR_ATTEMPT_COUNTER.record(attempts);
+          return username;
+        }
+      }
+
+      // update the search range to look for numbers of one more digit
+      // than the previous iteration
+      rangeMin = rangeMax;
+      rangeMax *= 10;
+    }
+    USERNAME_NOT_AVAILABLE_COUNTER.increment();
+    throw new UsernameNotAvailableException();
+  }
+
+  /**
+   * Strips the discriminator from a username, if it is present
+   *
+   * @param username the string username
+   * @return the nickname prefix of the username
+   */
+  public static String extractNickname(final String username) {
+    int sep = username.indexOf(SEPARATOR);
+    return sep == -1 ? username : username.substring(0, sep);
+  }
+
+  /**
+   * Generate a username from a nickname and discriminator
+   */
+  public static String fromParts(final String nickname, final int discriminator) throws IllegalArgumentException {
+    if (!isValidNickname(nickname)) {
+      throw new IllegalArgumentException("Invalid nickname " + nickname);
+    }
+    return nickname + SEPARATOR + discriminator;
+  }
+
+  public static boolean isValidNickname(final String nickname) {
+    return StringUtils.isNotBlank(nickname) && NICKNAME_PATTERN.matcher(nickname).matches();
+  }
+
+  /**
+   * Checks if the username consists of a valid nickname followed by an integer discriminator
+   *
+   * @param username string username to check
+   * @return true if the username is in standard form
+   */
+  public static boolean isStandardFormat(final String username) {
+    if (username == null) {
+      return false;
+    }
+    int sep = username.indexOf(SEPARATOR);
+    if (sep == -1) {
+      return false;
+    }
+    final String nickname = username.substring(0, sep);
+    if (!isValidNickname(nickname)) {
+      return false;
+    }
+
+    try {
+      int discriminator = Integer.parseInt(username.substring(sep + 1));
+      return discriminator > 0;
+    } catch (NumberFormatException e) {
+      return false;
+    }
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/UsernameValidator.java

@@ -1,26 +0,0 @@
-/*
- * Copyright 2013-2021 Signal Messenger, LLC
- * SPDX-License-Identifier: AGPL-3.0-only
- */
-
-package org.whispersystems.textsecuregcm.util;
-
-import org.apache.commons.lang3.StringUtils;
-import javax.validation.ConstraintValidator;
-import javax.validation.ConstraintValidatorContext;
-import java.util.regex.Pattern;
-
-public class UsernameValidator implements ConstraintValidator<Username, String> {
-
-  private static final Pattern USERNAME_PATTERN =
-      Pattern.compile("^[a-z_][a-z0-9_]{3,25}$", Pattern.CASE_INSENSITIVE);
-
-  @Override
-  public boolean isValid(final String username, final ConstraintValidatorContext context) {
-    return StringUtils.isNotBlank(username) && USERNAME_PATTERN.matcher(getCanonicalUsername(username)).matches();
-  }
-
-  public static String getCanonicalUsername(final String username) {
-    return username != null ? username.toLowerCase() : null;
-  }
-}

service/src/main/java/org/whispersystems/textsecuregcm/workers/AssignUsernameCommand.java

@@ -26,11 +26,13 @@ import org.whispersystems.textsecuregcm.WhisperServerConfiguration;
 import org.whispersystems.textsecuregcm.auth.ExternalServiceCredentialGenerator;
 import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicConfiguration;
 import org.whispersystems.textsecuregcm.push.PushLatencyManager;
+import org.whispersystems.textsecuregcm.experiment.ExperimentEnrollmentManager;
 import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisCluster;
 import org.whispersystems.textsecuregcm.securebackup.SecureBackupClient;
 import org.whispersystems.textsecuregcm.securestorage.SecureStorageClient;
 import org.whispersystems.textsecuregcm.sqs.DirectoryQueue;
+import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.Accounts;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.DeletedAccounts;
@@ -50,6 +52,7 @@ import org.whispersystems.textsecuregcm.storage.StoredVerificationCodeManager;
 import org.whispersystems.textsecuregcm.storage.UsernameNotAvailableException;
 import org.whispersystems.textsecuregcm.storage.VerificationCodeStore;
 import org.whispersystems.textsecuregcm.util.DynamoDbFromConfig;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 
@@ -68,11 +71,11 @@ public class AssignUsernameCommand extends EnvironmentCommand<WhisperServerConfi
   public void configure(Subparser subparser) {
     super.configure(subparser);
 
-    subparser.addArgument("-n", "--username")
-        .dest("username")
+    subparser.addArgument("-n", "--nickname")
+        .dest("nickname")
         .type(String.class)
         .required(true)
-        .help("The username to assign");
+        .help("The nickname (without discriminator) to assign");
 
     subparser.addArgument("-a", "--aci")
         .dest("aci")
@@ -109,6 +112,9 @@ public class AssignUsernameCommand extends EnvironmentCommand<WhisperServerConfi
         configuration.getAppConfig().getConfigurationName(), DynamicConfiguration.class);
     dynamicConfigurationManager.start();
 
+    ExperimentEnrollmentManager experimentEnrollmentManager = new ExperimentEnrollmentManager(
+        dynamicConfigurationManager);
+
     DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbFromConfig.asyncClient(
         configuration.getDynamoDbClientConfiguration(),
         software.amazon.awssdk.auth.credentials.InstanceProfileCredentialsProvider.create());
@@ -185,17 +191,20 @@ public class AssignUsernameCommand extends EnvironmentCommand<WhisperServerConfi
     DeletedAccountsManager deletedAccountsManager = new DeletedAccountsManager(deletedAccounts,
         deletedAccountsLockDynamoDbClient,
         configuration.getDynamoDbTables().getDeletedAccountsLock().getTableName());
+    UsernameGenerator usernameGenerator = new UsernameGenerator(configuration.getUsername());
     StoredVerificationCodeManager pendingAccountsManager = new StoredVerificationCodeManager(pendingAccounts);
     AccountsManager accountsManager = new AccountsManager(accounts, phoneNumberIdentifiers, cacheCluster,
         deletedAccountsManager, directoryQueue, keys, messagesManager, reservedUsernames, profilesManager,
-        pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, Clock.systemUTC());
+        pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, usernameGenerator,
+        experimentEnrollmentManager, Clock.systemUTC());
 
-    final String username = namespace.getString("username");
+    final String nickname = namespace.getString("nickname");
     final UUID accountIdentifier = UUID.fromString(namespace.getString("aci"));
 
     accountsManager.getByAccountIdentifier(accountIdentifier).ifPresentOrElse(account -> {
           try {
-            accountsManager.setUsername(account, username);
+            final Account result = accountsManager.setUsername(account, nickname, null);
+            System.out.println("New username: " + result.getUsername());
           } catch (final UsernameNotAvailableException e) {
             throw new IllegalArgumentException("Username already taken");
           }

service/src/main/java/org/whispersystems/textsecuregcm/workers/DeleteUserCommand.java

@@ -28,6 +28,7 @@ import org.whispersystems.textsecuregcm.WhisperServerConfiguration;
 import org.whispersystems.textsecuregcm.auth.ExternalServiceCredentialGenerator;
 import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicConfiguration;
 import org.whispersystems.textsecuregcm.push.PushLatencyManager;
+import org.whispersystems.textsecuregcm.experiment.ExperimentEnrollmentManager;
 import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisCluster;
 import org.whispersystems.textsecuregcm.securebackup.SecureBackupClient;
@@ -53,6 +54,7 @@ import org.whispersystems.textsecuregcm.storage.ReservedUsernames;
 import org.whispersystems.textsecuregcm.storage.StoredVerificationCodeManager;
 import org.whispersystems.textsecuregcm.storage.VerificationCodeStore;
 import org.whispersystems.textsecuregcm.util.DynamoDbFromConfig;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 
@@ -112,6 +114,9 @@ public class DeleteUserCommand extends EnvironmentCommand<WhisperServerConfigura
           configuration.getAppConfig().getConfigurationName(), DynamicConfiguration.class);
       dynamicConfigurationManager.start();
 
+      ExperimentEnrollmentManager experimentEnrollmentManager = new ExperimentEnrollmentManager(
+          dynamicConfigurationManager);
+
       DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbFromConfig.asyncClient(
           configuration.getDynamoDbClientConfiguration(),
           software.amazon.awssdk.auth.credentials.InstanceProfileCredentialsProvider.create());
@@ -189,9 +194,11 @@ public class DeleteUserCommand extends EnvironmentCommand<WhisperServerConfigura
           deletedAccountsLockDynamoDbClient,
           configuration.getDynamoDbTables().getDeletedAccountsLock().getTableName());
       StoredVerificationCodeManager pendingAccountsManager = new StoredVerificationCodeManager(pendingAccounts);
+      UsernameGenerator usernameGenerator = new UsernameGenerator(configuration.getUsername());
       AccountsManager accountsManager = new AccountsManager(accounts, phoneNumberIdentifiers, cacheCluster,
           deletedAccountsManager, directoryQueue, keys, messagesManager, reservedUsernames, profilesManager,
-          pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, clock);
+          pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, usernameGenerator,
+          experimentEnrollmentManager, clock);
 
       for (String user : users) {
         Optional<Account> account = accountsManager.getByE164(user);

service/src/main/java/org/whispersystems/textsecuregcm/workers/SetUserDiscoverabilityCommand.java

@@ -27,6 +27,7 @@ import org.whispersystems.textsecuregcm.WhisperServerConfiguration;
 import org.whispersystems.textsecuregcm.auth.ExternalServiceCredentialGenerator;
 import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicConfiguration;
 import org.whispersystems.textsecuregcm.push.PushLatencyManager;
+import org.whispersystems.textsecuregcm.experiment.ExperimentEnrollmentManager;
 import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisCluster;
 import org.whispersystems.textsecuregcm.securebackup.SecureBackupClient;
@@ -51,6 +52,7 @@ import org.whispersystems.textsecuregcm.storage.ReservedUsernames;
 import org.whispersystems.textsecuregcm.storage.StoredVerificationCodeManager;
 import org.whispersystems.textsecuregcm.storage.VerificationCodeStore;
 import org.whispersystems.textsecuregcm.util.DynamoDbFromConfig;
+import org.whispersystems.textsecuregcm.util.UsernameGenerator;
 import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 
@@ -115,6 +117,9 @@ public class SetUserDiscoverabilityCommand extends EnvironmentCommand<WhisperSer
           configuration.getAppConfig().getConfigurationName(), DynamicConfiguration.class);
       dynamicConfigurationManager.start();
 
+      ExperimentEnrollmentManager experimentEnrollmentManager = new ExperimentEnrollmentManager(
+          dynamicConfigurationManager);
+
       DynamoDbAsyncClient dynamoDbAsyncClient = DynamoDbFromConfig.asyncClient(
           configuration.getDynamoDbClientConfiguration(),
           software.amazon.awssdk.auth.credentials.InstanceProfileCredentialsProvider.create());
@@ -190,9 +195,11 @@ public class SetUserDiscoverabilityCommand extends EnvironmentCommand<WhisperSer
           deletedAccountsLockDynamoDbClient,
           configuration.getDynamoDbTables().getDeletedAccountsLock().getTableName());
       StoredVerificationCodeManager pendingAccountsManager = new StoredVerificationCodeManager(pendingAccounts);
+      UsernameGenerator usernameGenerator = new UsernameGenerator(configuration.getUsername());
       AccountsManager accountsManager = new AccountsManager(accounts, phoneNumberIdentifiers, cacheCluster,
           deletedAccountsManager, directoryQueue, keys, messagesManager, reservedUsernames, profilesManager,
-          pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, clock);
+          pendingAccountsManager, secureStorageClient, secureBackupClient, clientPresenceManager, usernameGenerator,
+          experimentEnrollmentManager, clock);
 
       Optional<Account> maybeAccount;