Refactor EppResourceUtils.loadByForeignKey(...) -> ForeignKeyUtils.loadResource(...) (#2864)

This doesn't make any underlying implementation details, and is mainly useful to reduce the number of diffs in PR #2852 (which does change implementation details) thus making that easier to review.
2026-04-14 13:37:25 +00:00 · 2025-10-28 15:47:37 -04:00
parent 8f69b48e87
commit ad07b32638
36 changed files with 156 additions and 154 deletions
--- a/core/src/main/java/google/registry/dns/PublishDnsUpdatesAction.java
+++ b/core/src/main/java/google/registry/dns/PublishDnsUpdatesAction.java
@@ -25,7 +25,6 @@ import static google.registry.dns.DnsModule.PARAM_REFRESH_REQUEST_TIME;
 import static google.registry.dns.DnsUtils.DNS_PUBLISH_PUSH_QUEUE_NAME;
 import static google.registry.dns.DnsUtils.requestDomainDnsRefresh;
 import static google.registry.dns.DnsUtils.requestHostDnsRefresh;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.request.Action.Method.POST;
 import static google.registry.request.RequestParameters.PARAM_TLD;
@@ -46,6 +45,7 @@ import google.registry.dns.DnsMetrics.CommitStatus;
 import google.registry.dns.DnsMetrics.PublishStatus;
 import google.registry.dns.writer.DnsWriter;
 import google.registry.groups.GmailClient;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.host.Host;
 import google.registry.model.registrar.Registrar;
@@ -237,7 +237,8 @@ public final class PublishDnsUpdatesAction implements Runnable, Callable<Void> {
            .findFirst()
            .ifPresent(
                dn -> {
-                  Optional<Domain> domain = loadByForeignKey(Domain.class, dn, clock.nowUtc());
+                  Optional<Domain> domain =
+                      ForeignKeyUtils.loadResource(Domain.class, dn, clock.nowUtc());
                  if (domain.isPresent()) {
                    notifyWithEmailAboutDnsUpdateFailure(
                        domain.get().getCurrentSponsorRegistrarId(), dn, false);
@@ -250,7 +251,8 @@ public final class PublishDnsUpdatesAction implements Runnable, Callable<Void> {
            .findFirst()
            .ifPresent(
                hn -> {
-                  Optional<Host> host = loadByForeignKey(Host.class, hn, clock.nowUtc());
+                  Optional<Host> host =
+                      ForeignKeyUtils.loadResource(Host.class, hn, clock.nowUtc());
                  if (host.isPresent()) {
                    notifyWithEmailAboutDnsUpdateFailure(
                        host.get().getPersistedCurrentSponsorRegistrarId(), hn, true);
--- a/core/src/main/java/google/registry/dns/RefreshDnsAction.java
+++ b/core/src/main/java/google/registry/dns/RefreshDnsAction.java
@@ -16,12 +16,12 @@ package google.registry.dns;

 import static google.registry.dns.DnsUtils.requestDomainDnsRefresh;
 import static google.registry.dns.DnsUtils.requestHostDnsRefresh;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;

 import google.registry.dns.DnsUtils.TargetType;
 import google.registry.model.EppResource;
 import google.registry.model.EppResource.ForeignKeyedEppResource;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.annotations.ExternalMessagingName;
 import google.registry.model.domain.Domain;
 import google.registry.model.host.Host;
@@ -79,7 +79,7 @@ public final class RefreshDnsAction implements Runnable {

  private <T extends EppResource & ForeignKeyedEppResource>
      T loadAndVerifyExistence(Class<T> clazz, String foreignKey) {
-    return loadByForeignKey(clazz, foreignKey, clock.nowUtc())
+    return ForeignKeyUtils.loadResource(clazz, foreignKey, clock.nowUtc())
        .orElseThrow(
            () ->
                new NotFoundException(
--- a/core/src/main/java/google/registry/dns/writer/clouddns/CloudDnsWriter.java
+++ b/core/src/main/java/google/registry/dns/writer/clouddns/CloudDnsWriter.java
@@ -17,7 +17,6 @@ package google.registry.dns.writer.clouddns;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static google.registry.dns.DnsUtils.getDnsAPlusAAAATtlForHost;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.util.DomainNameUtils.getSecondLevelDomain;

 import com.google.api.client.googleapis.json.GoogleJsonError;
@@ -37,6 +36,7 @@ import google.registry.config.RegistryConfig.Config;
 import google.registry.dns.writer.BaseDnsWriter;
 import google.registry.dns.writer.DnsWriter;
 import google.registry.dns.writer.DnsWriterZone;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.secdns.DomainDsData;
 import google.registry.model.host.Host;
@@ -123,7 +123,8 @@ public class CloudDnsWriter extends BaseDnsWriter {
    String absoluteDomainName = getAbsoluteHostName(domainName);

    // Load the target domain. Note that it can be absent if this domain was just deleted.
-    Optional<Domain> domain = loadByForeignKey(Domain.class, domainName, clock.nowUtc());
+    Optional<Domain> domain =
+        ForeignKeyUtils.loadResource(Domain.class, domainName, clock.nowUtc());

    // Return early if no DNS records should be published.
    // desiredRecordsBuilder is populated with an empty set to indicate that all existing records
@@ -189,7 +190,7 @@ public class CloudDnsWriter extends BaseDnsWriter {
    // Load the target host. Note that it can be absent if this host was just deleted.
    // desiredRecords is populated with an empty set to indicate that all existing records
    // should be deleted.
-    Optional<Host> host = loadByForeignKey(Host.class, hostName, clock.nowUtc());
+    Optional<Host> host = ForeignKeyUtils.loadResource(Host.class, hostName, clock.nowUtc());

    // Return early if the host is deleted.
    if (host.isEmpty()) {
--- a/core/src/main/java/google/registry/dns/writer/dnsupdate/DnsUpdateWriter.java
+++ b/core/src/main/java/google/registry/dns/writer/dnsupdate/DnsUpdateWriter.java
@@ -19,7 +19,6 @@ import static com.google.common.base.Verify.verify;
 import static com.google.common.collect.Sets.intersection;
 import static com.google.common.collect.Sets.union;
 import static google.registry.dns.DnsUtils.getDnsAPlusAAAATtlForHost;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;

 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
@@ -28,6 +27,7 @@ import com.google.common.net.InternetDomainName;
 import google.registry.config.RegistryConfig.Config;
 import google.registry.dns.writer.BaseDnsWriter;
 import google.registry.dns.writer.DnsWriterZone;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.secdns.DomainDsData;
 import google.registry.model.host.Host;
@@ -129,7 +129,8 @@ public class DnsUpdateWriter extends BaseDnsWriter {
   *     this domain refresh request
   */
  private void publishDomain(String domainName, String requestingHostName) {
-    Optional<Domain> domainOptional = loadByForeignKey(Domain.class, domainName, clock.nowUtc());
+    Optional<Domain> domainOptional =
+        ForeignKeyUtils.loadResource(Domain.class, domainName, clock.nowUtc());
    update.delete(toAbsoluteName(domainName), Type.ANY);
    // If the domain is now deleted, then don't update DNS for it.
    if (domainOptional.isPresent()) {
@@ -218,7 +219,7 @@ public class DnsUpdateWriter extends BaseDnsWriter {
  private void addInBailiwickNameServerSet(Domain domain, Update update) {
    for (String hostName :
        intersection(domain.loadNameserverHostNames(), domain.getSubordinateHosts())) {
-      Optional<Host> host = loadByForeignKey(Host.class, hostName, clock.nowUtc());
+      Optional<Host> host = ForeignKeyUtils.loadResource(Host.class, hostName, clock.nowUtc());
      checkState(host.isPresent(), "Host %s cannot be loaded", hostName);
      update.add(makeAddressSet(host.get()));
      update.add(makeV6AddressSet(host.get()));
--- a/core/src/main/java/google/registry/flows/ResourceFlowUtils.java
+++ b/core/src/main/java/google/registry/flows/ResourceFlowUtils.java
@@ -16,7 +16,6 @@ package google.registry.flows;

 import static com.google.common.collect.Sets.intersection;
 import static google.registry.model.EppResourceUtils.isLinked;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;

 import com.google.common.collect.ImmutableSet;
@@ -97,7 +96,7 @@ public final class ResourceFlowUtils {

  public static <R extends EppResource & ForeignKeyedEppResource> R loadAndVerifyExistence(
      Class<R> clazz, String targetId, DateTime now) throws ResourceDoesNotExistException {
-    return verifyExistence(clazz, targetId, loadByForeignKey(clazz, targetId, now));
+    return verifyExistence(clazz, targetId, ForeignKeyUtils.loadResource(clazz, targetId, now));
  }

  public static <R extends EppResource> R verifyExistence(
--- a/core/src/main/java/google/registry/flows/domain/DomainInfoFlow.java
+++ b/core/src/main/java/google/registry/flows/domain/DomainInfoFlow.java
@@ -20,7 +20,6 @@ import static google.registry.flows.ResourceFlowUtils.verifyOptionalAuthInfo;
 import static google.registry.flows.domain.DomainFlowUtils.addSecDnsExtensionIfPresent;
 import static google.registry.flows.domain.DomainFlowUtils.handleFeeRequest;
 import static google.registry.flows.domain.DomainFlowUtils.loadForeignKeyedDesignatedContacts;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;

 import com.google.common.collect.ImmutableList;
@@ -38,6 +37,7 @@ import google.registry.flows.custom.DomainInfoFlowCustomLogic;
 import google.registry.flows.custom.DomainInfoFlowCustomLogic.AfterValidationParameters;
 import google.registry.flows.custom.DomainInfoFlowCustomLogic.BeforeResponseParameters;
 import google.registry.flows.custom.DomainInfoFlowCustomLogic.BeforeResponseReturnData;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.DomainCommand.Info;
 import google.registry.model.domain.DomainCommand.Info.HostsRequest;
@@ -109,7 +109,8 @@ public final class DomainInfoFlow implements MutatingFlow {
    extensionManager.validate();
    DateTime now = clock.nowUtc();
    Domain domain =
-        verifyExistence(Domain.class, targetId, loadByForeignKey(Domain.class, targetId, now));
+        verifyExistence(
+            Domain.class, targetId, ForeignKeyUtils.loadResource(Domain.class, targetId, now));
    verifyOptionalAuthInfo(authInfo, domain);
    flowCustomLogic.afterValidation(
        AfterValidationParameters.newBuilder().setDomain(domain).build());
--- a/core/src/main/java/google/registry/flows/host/HostFlowUtils.java
+++ b/core/src/main/java/google/registry/flows/host/HostFlowUtils.java
@@ -15,7 +15,6 @@
 package google.registry.flows.host;

 import static google.registry.model.EppResourceUtils.isActive;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.tld.Tlds.findTldForName;
 import static google.registry.util.PreconditionsUtils.checkArgumentNotNull;
 import static java.util.stream.Collectors.joining;
@@ -29,6 +28,7 @@ import google.registry.flows.EppException.ParameterValuePolicyErrorException;
 import google.registry.flows.EppException.ParameterValueRangeErrorException;
 import google.registry.flows.EppException.ParameterValueSyntaxErrorException;
 import google.registry.flows.EppException.StatusProhibitsOperationException;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.eppcommon.StatusValue;
 import google.registry.util.Idn;
@@ -90,7 +90,8 @@ public class HostFlowUtils {
        hostName.parts().stream()
            .skip(hostName.parts().size() - (tld.get().parts().size() + 1))
            .collect(joining("."));
-    Optional<Domain> superordinateDomain = loadByForeignKey(Domain.class, domainName, now);
+    Optional<Domain> superordinateDomain =
+        ForeignKeyUtils.loadResource(Domain.class, domainName, now);
    if (superordinateDomain.isEmpty() || !isActive(superordinateDomain.get(), now)) {
      throw new SuperordinateDomainDoesNotExistException(domainName);
    }
--- a/core/src/main/java/google/registry/model/EppResourceUtils.java
+++ b/core/src/main/java/google/registry/model/EppResourceUtils.java
@@ -90,30 +90,6 @@ public final class EppResourceUtils {
    return (T) resource.cloneProjectedAtTime(now);
  }

-  /**
-   * Loads the last created version of an {@link EppResource} from the database by foreign key.
-   *
-   * <p>Returns empty if no resource with this foreign key was ever created, or if the most recently
-   * created resource was deleted before time "now".
-   *
-   * <p>Loading an {@link EppResource} by itself is not sufficient to know its current state since
-   * it may have various expirable conditions and status values that might implicitly change its
-   * state as time progresses even if it has not been updated in the database. Rather, the resource
-   * must be combined with a timestamp to view its current state. We use a global last updated
-   * timestamp on the resource's entity group (which is essentially free since all writes to the
-   * entity group must be serialized anyways) to guarantee monotonically increasing write times, and
-   * forward our projected time to the greater of this timestamp or "now". This guarantees that
-   * we're not projecting into the past.
-   *
-   * @param clazz the resource type to load
-   * @param foreignKey id to match
-   * @param now the current logical time to project resources at
-   */
-  public static <T extends EppResource> Optional<T> loadByForeignKey(
-      Class<T> clazz, String foreignKey, DateTime now) {
-    return loadByForeignKeyHelper(tm(), clazz, foreignKey, now, false);
-  }
-
  /**
   * Loads the last created version of an {@link EppResource} from the database by foreign key,
   * using a cache, if caching is enabled in config settings.
@@ -132,7 +108,6 @@ public final class EppResourceUtils {
   * <p>Do not call this cached version for anything that needs transactional consistency. It should
   * only be used when it's OK if the data is potentially being out of date, e.g. RDAP.
   *
-   * @param clazz the resource type to load
   * @param foreignKey id to match
   * @param now the current logical time to project resources at
   */
@@ -154,7 +129,7 @@ public final class EppResourceUtils {
    return loadByForeignKeyHelper(replicaTm(), clazz, foreignKey, now, true);
  }

-  private static <T extends EppResource> Optional<T> loadByForeignKeyHelper(
+  static <T extends EppResource> Optional<T> loadByForeignKeyHelper(
      TransactionManager txnManager,
      Class<T> clazz,
      String foreignKey,
--- a/core/src/main/java/google/registry/model/ForeignKeyUtils.java
+++ b/core/src/main/java/google/registry/model/ForeignKeyUtils.java
@@ -18,6 +18,7 @@ import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableMap.toImmutableMap;
 import static google.registry.config.RegistryConfig.getEppResourceCachingDuration;
 import static google.registry.config.RegistryConfig.getEppResourceMaxCachedEntries;
+import static google.registry.model.EppResourceUtils.loadByForeignKeyHelper;
 import static google.registry.persistence.transaction.TransactionManagerFactory.replicaTm;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;

@@ -91,6 +92,17 @@ public final class ForeignKeyUtils {
        .collect(toImmutableMap(Entry::getKey, e -> VKey.create(clazz, e.getValue().repoId())));
  }

+  /**
+   * Loads an {@link EppResource} from the database by foreign key.
+   *
+   * <p>Returns null if no resource with this foreign key was ever created or if the most recently
+   * created resource was deleted before time "now".
+   */
+  public static <E extends EppResource> Optional<E> loadResource(
+      Class<E> clazz, String foreignKey, DateTime now) {
+    return loadByForeignKeyHelper(tm(), clazz, foreignKey, now, false);
+  }
+
  /**
   * Helper method to load {@link VKey}s to all the most recent {@link EppResource}s for the given
   * foreign keys, regardless of whether they have been soft-deleted.
--- a/core/src/main/java/google/registry/tools/EnqueuePollMessageCommand.java
+++ b/core/src/main/java/google/registry/tools/EnqueuePollMessageCommand.java
@@ -15,7 +15,6 @@
 package google.registry.tools;

 import static com.google.common.base.Preconditions.checkArgument;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.reporting.HistoryEntry.Type.SYNTHETIC;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.util.CollectionUtils.isNullOrEmpty;
@@ -25,6 +24,7 @@ import com.beust.jcommander.Parameters;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Streams;
 import google.registry.config.RegistryConfig.Config;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.DomainHistory;
 import google.registry.model.poll.PollMessage;
@@ -86,7 +86,7 @@ class EnqueuePollMessageCommand extends MutatingCommand {
    tm().transact(
            () -> {
              Optional<Domain> domainOpt =
-                  loadByForeignKey(Domain.class, domainName, tm().getTransactionTime());
+                  ForeignKeyUtils.loadResource(Domain.class, domainName, tm().getTransactionTime());
              checkArgument(
                  domainOpt.isPresent(), "Domain %s doesn't exist or isn't active", domainName);
              Domain domain = domainOpt.get();
--- a/core/src/main/java/google/registry/tools/GetContactCommand.java
+++ b/core/src/main/java/google/registry/tools/GetContactCommand.java
@@ -14,10 +14,9 @@

 package google.registry.tools;

-import static google.registry.model.EppResourceUtils.loadByForeignKey;
-
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.contact.Contact;
 import java.util.List;

@@ -34,7 +33,9 @@ final class GetContactCommand extends GetEppResourceCommand {
  public void runAndPrint() {
    for (String contactId : mainParameters) {
      printResource(
-          "Contact", contactId, loadByForeignKey(Contact.class, contactId, readTimestamp));
+          "Contact",
+          contactId,
+          ForeignKeyUtils.loadResource(Contact.class, contactId, readTimestamp));
    }
  }
 }
--- a/core/src/main/java/google/registry/tools/GetDomainCommand.java
+++ b/core/src/main/java/google/registry/tools/GetDomainCommand.java
@@ -14,11 +14,11 @@

 package google.registry.tools;

-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;

 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.persistence.transaction.QueryComposer.Comparator;
 import google.registry.util.DomainNameUtils;
@@ -57,7 +57,7 @@ final class GetDomainCommand extends GetEppResourceCommand {
        printResource(
            "Domain",
            canonicalDomain,
-            loadByForeignKey(Domain.class, canonicalDomain, readTimestamp));
+            ForeignKeyUtils.loadResource(Domain.class, canonicalDomain, readTimestamp));
      }
    }
  }
--- a/core/src/main/java/google/registry/tools/GetHostCommand.java
+++ b/core/src/main/java/google/registry/tools/GetHostCommand.java
@@ -14,10 +14,9 @@

 package google.registry.tools;

-import static google.registry.model.EppResourceUtils.loadByForeignKey;
-
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.host.Host;
 import google.registry.util.DomainNameUtils;
 import java.util.List;
@@ -35,6 +34,9 @@ final class GetHostCommand extends GetEppResourceCommand {
  public void runAndPrint() {
    mainParameters.stream()
        .map(DomainNameUtils::canonicalizeHostname)
-        .forEach(h -> printResource("Host", h, loadByForeignKey(Host.class, h, readTimestamp)));
+        .forEach(
+            h ->
+                printResource(
+                    "Host", h, ForeignKeyUtils.loadResource(Host.class, h, readTimestamp)));
  }
 }
--- a/core/src/main/java/google/registry/tools/RenewDomainCommand.java
+++ b/core/src/main/java/google/registry/tools/RenewDomainCommand.java
@@ -16,7 +16,6 @@ package google.registry.tools;

 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Strings.isNullOrEmpty;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.util.CollectionUtils.findDuplicates;
 import static google.registry.util.PreconditionsUtils.checkArgumentNotNull;
 import static google.registry.util.PreconditionsUtils.checkArgumentPresent;
@@ -25,6 +24,7 @@ import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
 import com.google.common.base.Joiner;
 import com.google.template.soy.data.SoyMapData;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.tools.soy.DomainRenewSoyInfo;
 import google.registry.util.Clock;
@@ -77,7 +77,7 @@ final class RenewDomainCommand extends MutatingEppToolCommand {
    checkArgument(period < 10, "Cannot renew domains for 10 or more years");
    DateTime now = clock.nowUtc();
    for (String domainName : mainParameters) {
-      Optional<Domain> domainOptional = loadByForeignKey(Domain.class, domainName, now);
+      Optional<Domain> domainOptional = ForeignKeyUtils.loadResource(Domain.class, domainName, now);
      checkArgumentPresent(domainOptional, "Domain '%s' does not exist or is deleted", domainName);
      setSoyTemplate(DomainRenewSoyInfo.getInstance(), DomainRenewSoyInfo.RENEWDOMAIN);
      Domain domain = domainOptional.get();
--- a/core/src/main/java/google/registry/tools/UniformRapidSuspensionCommand.java
+++ b/core/src/main/java/google/registry/tools/UniformRapidSuspensionCommand.java
@@ -18,7 +18,6 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.Sets.difference;
 import static google.registry.model.EppResourceUtils.checkResourcesExist;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.util.PreconditionsUtils.checkArgumentPresent;

@@ -31,6 +30,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.template.soy.data.SoyListData;
 import com.google.template.soy.data.SoyMapData;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.secdns.DomainDsData;
 import google.registry.model.eppcommon.StatusValue;
@@ -130,7 +130,7 @@ final class UniformRapidSuspensionCommand extends MutatingEppToolCommand {
  protected void initMutatingEppToolCommand() {
    superuser = true;
    DateTime now = clock.nowUtc();
-    Optional<Domain> domainOpt = loadByForeignKey(Domain.class, domainName, now);
+    Optional<Domain> domainOpt = ForeignKeyUtils.loadResource(Domain.class, domainName, now);
    checkArgumentPresent(domainOpt, "Domain '%s' does not exist or is deleted", domainName);
    Domain domain = domainOpt.get();
    Set<String> missingHosts = difference(newHosts, checkResourcesExist(Host.class, newHosts, now));
--- a/core/src/main/java/google/registry/tools/UnrenewDomainCommand.java
+++ b/core/src/main/java/google/registry/tools/UnrenewDomainCommand.java
@@ -19,7 +19,6 @@ import static com.google.common.base.Preconditions.checkState;
 import static google.registry.flows.domain.DomainFlowUtils.newAutorenewBillingEvent;
 import static google.registry.flows.domain.DomainFlowUtils.newAutorenewPollMessage;
 import static google.registry.flows.domain.DomainFlowUtils.updateAutorenewRecurrenceEndTime;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.util.DateTimeUtils.START_OF_TIME;
 import static google.registry.util.DateTimeUtils.isBeforeOrAt;
@@ -92,7 +91,7 @@ class UnrenewDomainCommand extends ConfirmingCommand {
        domainsNonexistentBuilder.add(domainName);
        continue;
      }
-      Optional<Domain> domain = loadByForeignKey(Domain.class, domainName, now);
+      Optional<Domain> domain = ForeignKeyUtils.loadResource(Domain.class, domainName, now);
      if (domain.isEmpty() || domain.get().getStatusValues().contains(StatusValue.PENDING_DELETE)) {
        domainsDeletingBuilder.add(domainName);
        continue;
@@ -143,7 +142,7 @@ class UnrenewDomainCommand extends ConfirmingCommand {
    StringBuilder resultBuilder = new StringBuilder();
    DateTime now = clock.nowUtc();
    for (String domainName : mainParameters) {
-      Domain domain = loadByForeignKey(Domain.class, domainName, now).get();
+      Domain domain = ForeignKeyUtils.loadResource(Domain.class, domainName, now).get();
      DateTime previousTime = domain.getRegistrationExpirationTime();
      DateTime newTime = leapSafeSubtractYears(previousTime, period);
      resultBuilder.append(
@@ -166,7 +165,7 @@ class UnrenewDomainCommand extends ConfirmingCommand {
  private void unrenewDomain(String domainName) {
    tm().assertInTransaction();
    DateTime now = tm().getTransactionTime();
-    Optional<Domain> domainOptional = loadByForeignKey(Domain.class, domainName, now);
+    Optional<Domain> domainOptional = ForeignKeyUtils.loadResource(Domain.class, domainName, now);
    // Transactional sanity checks on the off chance that something changed between init() running
    // and here.
    checkState(
--- a/core/src/main/java/google/registry/tools/UpdateDomainCommand.java
+++ b/core/src/main/java/google/registry/tools/UpdateDomainCommand.java
@@ -16,7 +16,6 @@ package google.registry.tools;

 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.domain.rgp.GracePeriodStatus.AUTO_RENEW;
 import static google.registry.model.eppcommon.StatusValue.PENDING_DELETE;
 import static google.registry.model.eppcommon.StatusValue.SERVER_UPDATE_PROHIBITED;
@@ -31,6 +30,7 @@ import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Sets;
 import com.google.common.flogger.FluentLogger;
 import com.google.template.soy.data.SoyMapData;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.DesignatedContact;
 import google.registry.model.domain.Domain;
 import google.registry.model.domain.GracePeriodBase;
@@ -184,7 +184,7 @@ final class UpdateDomainCommand extends CreateOrUpdateDomainCommand {
    ImmutableSet.Builder<String> autorenewGracePeriodWarningDomains = new ImmutableSet.Builder<>();
    DateTime now = clock.nowUtc();
    for (String domainName : domains) {
-      Optional<Domain> domainOptional = loadByForeignKey(Domain.class, domainName, now);
+      Optional<Domain> domainOptional = ForeignKeyUtils.loadResource(Domain.class, domainName, now);
      checkArgumentPresent(domainOptional, "Domain '%s' does not exist or is deleted", domainName);
      Domain domain = domainOptional.get();
      checkArgument(
--- a/core/src/main/java/google/registry/tools/UpdateRecurrenceCommand.java
+++ b/core/src/main/java/google/registry/tools/UpdateRecurrenceCommand.java
@@ -23,7 +23,7 @@ import com.beust.jcommander.Parameters;
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import google.registry.model.EppResourceUtils;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingBase.RenewalPriceBehavior;
 import google.registry.model.billing.BillingRecurrence;
 import google.registry.model.domain.Domain;
@@ -164,7 +164,7 @@ public class UpdateRecurrenceCommand extends ConfirmingCommand {
    DateTime now = tm().getTransactionTime();
    for (String domainName : mainParameters) {
      Domain domain =
-          EppResourceUtils.loadByForeignKey(Domain.class, domainName, now)
+          ForeignKeyUtils.loadResource(Domain.class, domainName, now)
              .orElseThrow(
                  () ->
                      new IllegalArgumentException(
--- a/core/src/main/java/google/registry/tools/javascrap/RecreateBillingRecurrencesCommand.java
+++ b/core/src/main/java/google/registry/tools/javascrap/RecreateBillingRecurrencesCommand.java
@@ -23,7 +23,7 @@ import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
-import google.registry.model.EppResourceUtils;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingRecurrence;
 import google.registry.model.common.TimeOfYear;
 import google.registry.model.domain.Domain;
@@ -61,11 +61,12 @@ public class RecreateBillingRecurrencesCommand extends ConfirmingCommand {
                  convertRecurrencesWithoutSaving(existingRecurrences);
              return String.format(
                  """
-                      Create new BillingRecurrence(s)?
-                      Existing recurrences:
-                      %s
-                      New recurrences:
-                      %s""",
+                  Create new BillingRecurrence(s)?
+                  Existing recurrences:
+                  %s
+                  New recurrences:
+                  %s\
+                  """,
                  Joiner.on('\n').join(existingRecurrences), Joiner.on('\n').join(newRecurrences));
            });
  }
@@ -114,7 +115,7 @@ public class RecreateBillingRecurrencesCommand extends ConfirmingCommand {
    DateTime now = tm().getTransactionTime();
    for (String domainName : mainParameters) {
      Domain domain =
-          EppResourceUtils.loadByForeignKey(Domain.class, domainName, now)
+          ForeignKeyUtils.loadResource(Domain.class, domainName, now)
              .orElseThrow(
                  () ->
                      new IllegalArgumentException(
--- a/core/src/test/java/google/registry/batch/DeleteProberDataActionTest.java
+++ b/core/src/test/java/google/registry/batch/DeleteProberDataActionTest.java
@@ -16,7 +16,6 @@ package google.registry.batch;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.domain.rgp.GracePeriodStatus.ADD;
 import static google.registry.testing.DatabaseHelper.assertDomainDnsRequests;
 import static google.registry.testing.DatabaseHelper.createTld;
@@ -32,6 +31,7 @@ import static org.joda.time.DateTimeZone.UTC;
 import static org.junit.jupiter.api.Assertions.assertThrows;

 import com.google.common.collect.ImmutableSet;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.ImmutableObject;
 import google.registry.model.billing.BillingBase.Reason;
 import google.registry.model.billing.BillingEvent;
@@ -202,7 +202,8 @@ class DeleteProberDataActionTest {
                .build());
    action.run();
    DateTime timeAfterDeletion = DateTime.now(UTC);
-    assertThat(loadByForeignKey(Domain.class, "blah.ib-any.test", timeAfterDeletion)).isEmpty();
+    assertThat(ForeignKeyUtils.loadResource(Domain.class, "blah.ib-any.test", timeAfterDeletion))
+        .isEmpty();
    assertThat(loadByEntity(domain).getDeletionTime()).isLessThan(timeAfterDeletion);
    assertDomainDnsRequests("blah.ib-any.test");
  }
@@ -219,7 +220,8 @@ class DeleteProberDataActionTest {
    DateTime timeAfterDeletion = DateTime.now(UTC);
    resetAction();
    action.run();
-    assertThat(loadByForeignKey(Domain.class, "blah.ib-any.test", timeAfterDeletion)).isEmpty();
+    assertThat(ForeignKeyUtils.loadResource(Domain.class, "blah.ib-any.test", timeAfterDeletion))
+        .isEmpty();
    assertThat(loadByEntity(domain).getDeletionTime()).isLessThan(timeAfterDeletion);
    assertDomainDnsRequests("blah.ib-any.test");
  }
@@ -232,7 +234,8 @@ class DeleteProberDataActionTest {
            .setCreationTimeForTest(DateTime.now(UTC).minusSeconds(1))
            .build());
    action.run();
-    Optional<Domain> domain = loadByForeignKey(Domain.class, "blah.ib-any.test", DateTime.now(UTC));
+    Optional<Domain> domain =
+        ForeignKeyUtils.loadResource(Domain.class, "blah.ib-any.test", DateTime.now(UTC));
    assertThat(domain).isPresent();
    assertThat(domain.get().getDeletionTime()).isEqualTo(END_OF_TIME);
  }
--- a/core/src/test/java/google/registry/beam/billing/ExpandBillingRecurrencesPipelineTest.java
+++ b/core/src/test/java/google/registry/beam/billing/ExpandBillingRecurrencesPipelineTest.java
@@ -16,7 +16,6 @@ package google.registry.beam.billing;

 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.ImmutableObjectSubject.immutableObjectCorrespondence;
 import static google.registry.model.common.Cursor.CursorType.RECURRING_BILLING;
 import static google.registry.model.domain.Period.Unit.YEARS;
@@ -37,6 +36,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import google.registry.beam.TestPipelineExtension;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingBase.Flag;
 import google.registry.model.billing.BillingBase.Reason;
 import google.registry.model.billing.BillingEvent;
@@ -115,7 +115,7 @@ public class ExpandBillingRecurrencesPipelineTest {
    // Set up the database.
    createTld("tld");
    billingRecurrence = createDomainAtTime("example.tld", startTime.minusYears(1).plusHours(12));
-    domain = loadByForeignKey(Domain.class, "example.tld", clock.nowUtc()).get();
+    domain = ForeignKeyUtils.loadResource(Domain.class, "example.tld", clock.nowUtc()).get();
  }

  @Test
@@ -321,7 +321,8 @@ public class ExpandBillingRecurrencesPipelineTest {
            .build());
    DateTime otherCreateTime = startTime.minusYears(1).plusHours(5);
    BillingRecurrence otherBillingRecurrence = createDomainAtTime("other.test", otherCreateTime);
-    Domain otherDomain = loadByForeignKey(Domain.class, "other.test", clock.nowUtc()).get();
+    Domain otherDomain =
+        ForeignKeyUtils.loadResource(Domain.class, "other.test", clock.nowUtc()).get();

    options.setTargetParallelism(numOfThreads);
    runPipeline();
--- a/core/src/test/java/google/registry/flows/EppLifecycleDomainTest.java
+++ b/core/src/test/java/google/registry/flows/EppLifecycleDomainTest.java
@@ -15,7 +15,7 @@
 package google.registry.flows;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
+import static google.registry.model.ForeignKeyUtils.loadResource;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_OPTIONAL;
 import static google.registry.model.common.FeatureFlag.FeatureStatus.INACTIVE;
 import static google.registry.model.eppoutput.Result.Code.SUCCESS;
@@ -349,7 +349,7 @@ class EppLifecycleDomainTest extends EppTestCase {
                "UPDATE", "2000-06-03T00:00:00Z"));

    Domain domain =
-        loadByForeignKey(Domain.class, "example.tld", DateTime.parse("2000-06-03T04:00:00Z")).get();
+        loadResource(Domain.class, "example.tld", DateTime.parse("2000-06-03T04:00:00Z")).get();

    DateTime deleteTime = DateTime.parse("2000-06-04T00:00:00Z");
    // Delete domain example.tld during both grace periods.
@@ -410,7 +410,7 @@ class EppLifecycleDomainTest extends EppTestCase {
                "CRDATE", "2000-06-01T00:02:00.0Z",
                "EXDATE", "2002-06-01T00:02:00.0Z"));

-    Domain domain = loadByForeignKey(Domain.class, "example.tld", createTime.plusHours(1)).get();
+    Domain domain = loadResource(Domain.class, "example.tld", createTime.plusHours(1)).get();

    // Delete domain example.tld within the add grace period.
    DateTime deleteTime = createTime.plusDays(1);
@@ -492,7 +492,7 @@ class EppLifecycleDomainTest extends EppTestCase {
                "CODE", "2303", "MSG", "The domain with given ID (example.tld) doesn't exist."));

    Domain domain =
-        loadByForeignKey(Domain.class, "example.tld", DateTime.parse("2000-08-01T00:02:00Z")).get();
+        loadResource(Domain.class, "example.tld", DateTime.parse("2000-08-01T00:02:00Z")).get();
    // Verify that the autorenew was ended and that the one-time billing event is not canceled.
    assertBillingEventsForResource(
        domain,
@@ -532,7 +532,7 @@ class EppLifecycleDomainTest extends EppTestCase {
        .hasResponse("domain_create_response_eap_fee.xml");

    Domain domain =
-        loadByForeignKey(Domain.class, "example.tld", DateTime.parse("2000-06-01T00:03:00Z")).get();
+        loadResource(Domain.class, "example.tld", DateTime.parse("2000-06-01T00:03:00Z")).get();

    // Delete domain example.tld within the add grade period.
    DateTime deleteTime = createTime.plusDays(1);
--- a/core/src/test/java/google/registry/flows/EppLifecycleHostTest.java
+++ b/core/src/test/java/google/registry/flows/EppLifecycleHostTest.java
@@ -15,7 +15,7 @@
 package google.registry.flows;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
+import static google.registry.model.ForeignKeyUtils.loadResource;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_OPTIONAL;
 import static google.registry.model.common.FeatureFlag.FeatureStatus.INACTIVE;
 import static google.registry.model.eppoutput.Result.Code.SUCCESS;
@@ -230,9 +230,9 @@ class EppLifecycleHostTest extends EppTestCase {
    DateTime timeAfterCreates = DateTime.parse("2000-06-01T00:06:00Z");

    Host exampleBarFooTldHost =
-        loadByForeignKey(Host.class, "ns1.example.bar.foo.tld", timeAfterCreates).get();
+        loadResource(Host.class, "ns1.example.bar.foo.tld", timeAfterCreates).get();
    Domain exampleBarFooTldDomain =
-        loadByForeignKey(Domain.class, "example.bar.foo.tld", timeAfterCreates).get();
+        loadResource(Domain.class, "example.bar.foo.tld", timeAfterCreates).get();
    assertAboutHosts()
        .that(exampleBarFooTldHost)
        .hasSuperordinateDomain(exampleBarFooTldDomain.createVKey());
@@ -240,16 +240,16 @@ class EppLifecycleHostTest extends EppTestCase {
        .containsExactly("ns1.example.bar.foo.tld");

    Host exampleFooTldHost =
-        loadByForeignKey(Host.class, "ns1.example.foo.tld", timeAfterCreates).get();
+        loadResource(Host.class, "ns1.example.foo.tld", timeAfterCreates).get();
    Domain exampleFooTldDomain =
-        loadByForeignKey(Domain.class, "example.foo.tld", timeAfterCreates).get();
+        loadResource(Domain.class, "example.foo.tld", timeAfterCreates).get();
    assertAboutHosts()
        .that(exampleFooTldHost)
        .hasSuperordinateDomain(exampleFooTldDomain.createVKey());
    assertThat(exampleFooTldDomain.getSubordinateHosts()).containsExactly("ns1.example.foo.tld");

-    Host exampleTldHost = loadByForeignKey(Host.class, "ns1.example.tld", timeAfterCreates).get();
-    Domain exampleTldDomain = loadByForeignKey(Domain.class, "example.tld", timeAfterCreates).get();
+    Host exampleTldHost = loadResource(Host.class, "ns1.example.tld", timeAfterCreates).get();
+    Domain exampleTldDomain = loadResource(Domain.class, "example.tld", timeAfterCreates).get();
    assertAboutHosts().that(exampleTldHost).hasSuperordinateDomain(exampleTldDomain.createVKey());
    assertThat(exampleTldDomain.getSubordinateHosts()).containsExactly("ns1.example.tld");

--- a/core/src/test/java/google/registry/flows/ResourceFlowTestCase.java
+++ b/core/src/test/java/google/registry/flows/ResourceFlowTestCase.java
@@ -14,7 +14,6 @@

 package google.registry.flows;

-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.ImmutableObjectSubject.assertAboutImmutableObjects;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.testing.LogsSubject.assertAboutLogs;
@@ -24,6 +23,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import com.google.common.testing.TestLogHandler;
 import google.registry.model.EppResource;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.contact.ContactBase;
 import google.registry.model.contact.ContactHistory;
 import google.registry.model.domain.DomainBase;
@@ -72,7 +72,8 @@ public abstract class ResourceFlowTestCase<F extends Flow, R extends EppResource

  @Nullable
  protected R reloadResourceByForeignKey(DateTime now) throws Exception {
-    return loadByForeignKey(getResourceClass(), getUniqueIdFromCommand(), now).orElse(null);
+    return ForeignKeyUtils.loadResource(getResourceClass(), getUniqueIdFromCommand(), now)
+        .orElse(null);
  }

  @Nullable
--- a/core/src/test/java/google/registry/flows/domain/DomainDeleteFlowTest.java
+++ b/core/src/test/java/google/registry/flows/domain/DomainDeleteFlowTest.java
@@ -21,7 +21,6 @@ import static google.registry.batch.AsyncTaskEnqueuer.PARAM_RESAVE_TIMES;
 import static google.registry.batch.AsyncTaskEnqueuer.PARAM_RESOURCE_KEY;
 import static google.registry.batch.AsyncTaskEnqueuer.QUEUE_ASYNC_ACTIONS;
 import static google.registry.flows.domain.DomainTransferFlowTestCase.persistWithPendingTransfer;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.reporting.DomainTransactionRecord.TransactionReportField.DELETED_DOMAINS_GRACE;
 import static google.registry.model.reporting.DomainTransactionRecord.TransactionReportField.DELETED_DOMAINS_NOGRACE;
 import static google.registry.model.reporting.DomainTransactionRecord.TransactionReportField.NET_ADDS_10_YR;
@@ -76,6 +75,7 @@ import google.registry.flows.domain.DomainFlowUtils.BadCommandForRegistryPhaseEx
 import google.registry.flows.domain.DomainFlowUtils.NotAuthorizedForTldException;
 import google.registry.flows.exceptions.OnlyToolCanPassMetadataException;
 import google.registry.flows.exceptions.ResourceStatusProhibitsOperationException;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingBase.Flag;
 import google.registry.model.billing.BillingBase.Reason;
 import google.registry.model.billing.BillingCancellation;
@@ -731,7 +731,7 @@ class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow, Domain
    // Add a nameserver.
    Host host = persistResource(newHost("ns1.example.tld"));
    persistResource(
-        loadByForeignKey(Domain.class, getUniqueIdFromCommand(), clock.nowUtc())
+        ForeignKeyUtils.loadResource(Domain.class, getUniqueIdFromCommand(), clock.nowUtc())
            .get()
            .asBuilder()
            .setNameservers(ImmutableSet.of(host.createVKey()))
@@ -742,7 +742,9 @@ class DomainDeleteFlowTest extends ResourceFlowTestCase<DomainDeleteFlow, Domain
            .asBuilder()
            .setRegistrant(
                Optional.of(
-                    loadByForeignKey(Contact.class, "sh8013", clock.nowUtc()).get().createVKey()))
+                    ForeignKeyUtils.loadResource(Contact.class, "sh8013", clock.nowUtc())
+                        .get()
+                        .createVKey()))
            .setNameservers(ImmutableSet.of(host.createVKey()))
            .setDeletionTime(START_OF_TIME)
            .build());
--- a/core/src/test/java/google/registry/flows/domain/DomainUpdateFlowTest.java
+++ b/core/src/test/java/google/registry/flows/domain/DomainUpdateFlowTest.java
@@ -18,7 +18,7 @@ import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.Sets.union;
 import static com.google.common.io.BaseEncoding.base16;
 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
+import static google.registry.model.ForeignKeyUtils.loadResource;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_OPTIONAL;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_PROHIBITED;
 import static google.registry.model.common.FeatureFlag.FeatureStatus.ACTIVE;
@@ -161,7 +161,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
  }

  private void persistDomainWithRegistrant() throws Exception {
-    Host host = loadByForeignKey(Host.class, "ns1.example.foo", clock.nowUtc()).get();
+    Host host = loadResource(Host.class, "ns1.example.foo", clock.nowUtc()).get();
    Domain domain =
        persistResource(
            DatabaseHelper.newDomain(getUniqueIdFromCommand())
@@ -185,7 +185,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
  }

  private Domain persistDomain() throws Exception {
-    Host host = loadByForeignKey(Host.class, "ns1.example.foo", clock.nowUtc()).get();
+    Host host = loadResource(Host.class, "ns1.example.foo", clock.nowUtc()).get();
    Domain domain =
        persistResource(
            DatabaseHelper.newDomain(getUniqueIdFromCommand())
@@ -368,7 +368,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
    for (int i = 1; i < 15; i++) {
      if (i != 2) { // Skip 2 since that's the one that the tests will add.
        nameservers.add(
-            loadByForeignKey(Host.class, String.format("ns%d.example.foo", i), clock.nowUtc())
+            loadResource(Host.class, String.format("ns%d.example.foo", i), clock.nowUtc())
                .get()
                .createVKey());
      }
@@ -476,9 +476,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
            .addSubordinateHost("ns2.example.tld")
            .setNameservers(
                ImmutableSet.of(
-                    loadByForeignKey(Host.class, "ns1.example.tld", clock.nowUtc())
-                        .get()
-                        .createVKey()))
+                    loadResource(Host.class, "ns1.example.tld", clock.nowUtc()).get().createVKey()))
            .build());
    clock.advanceOneMilli();
    assertMutatingFlow(true);
@@ -486,8 +484,8 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
    domain = reloadResourceByForeignKey();
    assertThat(domain.getNameservers()).containsExactly(addedHost.createVKey());
    assertThat(domain.getSubordinateHosts()).containsExactly("ns1.example.tld", "ns2.example.tld");
-    Host existingHost = loadByForeignKey(Host.class, "ns1.example.tld", clock.nowUtc()).get();
-    addedHost = loadByForeignKey(Host.class, "ns2.example.tld", clock.nowUtc()).get();
+    Host existingHost = loadResource(Host.class, "ns1.example.tld", clock.nowUtc()).get();
+    addedHost = loadResource(Host.class, "ns2.example.tld", clock.nowUtc()).get();
    assertThat(existingHost.getSuperordinateDomain()).isEqualTo(domain.createVKey());
    assertThat(addedHost.getSuperordinateDomain()).isEqualTo(domain.createVKey());
  }
@@ -496,7 +494,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
  void testSuccess_registrantMovedToTechContact() throws Exception {
    setEppInput("domain_update_registrant_to_tech.xml");
    persistReferencedEntities();
-    Contact sh8013 = loadByForeignKey(Contact.class, "sh8013", clock.nowUtc()).get();
+    Contact sh8013 = loadResource(Contact.class, "sh8013", clock.nowUtc()).get();
    persistResource(
        DatabaseHelper.newDomain(getUniqueIdFromCommand())
            .asBuilder()
@@ -510,7 +508,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
  void testSuccess_multipleReferencesToSameContactRemoved() throws Exception {
    setEppInput("domain_update_remove_multiple_contacts.xml");
    persistReferencedEntities();
-    Contact sh8013 = loadByForeignKey(Contact.class, "sh8013", clock.nowUtc()).get();
+    Contact sh8013 = loadResource(Contact.class, "sh8013", clock.nowUtc()).get();
    VKey<Contact> sh8013Key = sh8013.createVKey();
    persistResource(
        DatabaseHelper.newDomain(getUniqueIdFromCommand())
@@ -1207,7 +1205,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
            .setContacts(
                DesignatedContact.create(
                    Type.TECH,
-                    loadByForeignKey(Contact.class, "foo", clock.nowUtc()).get().createVKey()))
+                    loadResource(Contact.class, "foo", clock.nowUtc()).get().createVKey()))
            .build());
    EppException thrown = assertThrows(DuplicateContactForRoleException.class, this::runFlow);
    assertAboutEppExceptions().that(thrown).marshalsToXml();
@@ -1511,9 +1509,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
            .asBuilder()
            .setNameservers(
                ImmutableSet.of(
-                    loadByForeignKey(Host.class, "ns1.example.foo", clock.nowUtc())
-                        .get()
-                        .createVKey()))
+                    loadResource(Host.class, "ns1.example.foo", clock.nowUtc()).get().createVKey()))
            .build());
    EppException thrown = assertThrows(AddRemoveSameValueException.class, this::runFlow);
    assertAboutEppExceptions().that(thrown).marshalsToXml();
@@ -1530,7 +1526,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
            .setContacts(
                DesignatedContact.create(
                    Type.TECH,
-                    loadByForeignKey(Contact.class, "sh8013", clock.nowUtc()).get().createVKey()))
+                    loadResource(Contact.class, "sh8013", clock.nowUtc()).get().createVKey()))
            .build());
    EppException thrown = assertThrows(AddRemoveSameValueException.class, this::runFlow);
    assertAboutEppExceptions().that(thrown).marshalsToXml();
@@ -1690,7 +1686,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
    persistReferencedEntities();
    persistDomain();
    persistResource(
-        loadByForeignKey(Contact.class, "mak21", clock.nowUtc())
+        loadResource(Contact.class, "mak21", clock.nowUtc())
            .get()
            .asBuilder()
            .addStatusValue(PENDING_DELETE)
@@ -1706,7 +1702,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
    persistReferencedEntities();
    persistDomain();
    persistResource(
-        loadByForeignKey(Host.class, "ns2.example.foo", clock.nowUtc())
+        loadResource(Host.class, "ns2.example.foo", clock.nowUtc())
            .get()
            .asBuilder()
            .addStatusValue(PENDING_DELETE)
@@ -1761,11 +1757,10 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
            .build());
    assertThat(reloadResourceByForeignKey().getNameservers())
        .doesNotContain(
-            loadByForeignKey(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey());
+            loadResource(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey());
    runFlow();
    assertThat(reloadResourceByForeignKey().getNameservers())
-        .contains(
-            loadByForeignKey(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey());
+        .contains(loadResource(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey());
  }

  @Test
@@ -1832,7 +1827,7 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
        reloadResourceByForeignKey()
            .asBuilder()
            .addNameserver(
-                loadByForeignKey(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey())
+                loadResource(Host.class, "ns2.example.foo", clock.nowUtc()).get().createVKey())
            .build());
    persistResource(
        Tld.get("tld")
@@ -1841,13 +1836,12 @@ class DomainUpdateFlowTest extends ResourceFlowTestCase<DomainUpdateFlow, Domain
                ImmutableSet.of("ns1.example.foo", "ns2.example.foo"))
            .build());
    assertThat(reloadResourceByForeignKey().getNameservers())
-        .contains(
-            loadByForeignKey(Host.class, "ns1.example.foo", clock.nowUtc()).get().createVKey());
+        .contains(loadResource(Host.class, "ns1.example.foo", clock.nowUtc()).get().createVKey());
    clock.advanceOneMilli();
    runFlow();
    assertThat(reloadResourceByForeignKey().getNameservers())
        .doesNotContain(
-            loadByForeignKey(Host.class, "ns1.example.foo", clock.nowUtc())
+            loadResource(Host.class, "ns1.example.foo", clock.nowUtc())
                .map(ImmutableObject::createVKey)
                .get());
  }
--- a/core/src/test/java/google/registry/flows/host/HostCreateFlowTest.java
+++ b/core/src/test/java/google/registry/flows/host/HostCreateFlowTest.java
@@ -15,7 +15,6 @@
 package google.registry.flows.host;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.testing.DatabaseHelper.assertHostDnsRequests;
 import static google.registry.testing.DatabaseHelper.assertNoBillingEvents;
 import static google.registry.testing.DatabaseHelper.assertNoDnsRequests;
@@ -48,6 +47,7 @@ import google.registry.flows.host.HostFlowUtils.HostNameTooShallowException;
 import google.registry.flows.host.HostFlowUtils.InvalidHostNameException;
 import google.registry.flows.host.HostFlowUtils.SuperordinateDomainDoesNotExistException;
 import google.registry.flows.host.HostFlowUtils.SuperordinateDomainInPendingDeleteException;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.model.eppcommon.StatusValue;
 import google.registry.model.host.Host;
@@ -69,9 +69,10 @@ class HostCreateFlowTest extends ResourceFlowTestCase<HostCreateFlow, Host> {
    setEppHostCreateInput(
        hostName,
        """
-            <host:addr ip="v4">192.0.2.2</host:addr>
-            <host:addr ip="v4">192.0.2.29</host:addr>
-            <host:addr ip="v6">1080:0:0:0:8:800:200C:417A</host:addr>""");
+        <host:addr ip="v4">192.0.2.2</host:addr>
+        <host:addr ip="v4">192.0.2.29</host:addr>
+        <host:addr ip="v6">1080:0:0:0:8:800:200C:417A</host:addr>\
+        """);
  }

  HostCreateFlowTest() {
@@ -126,7 +127,7 @@ class HostCreateFlowTest extends ResourceFlowTestCase<HostCreateFlow, Host> {
    doSuccessfulInternalTest("tld");
    Host host = reloadResourceByForeignKey();
    Domain superordinateDomain =
-        loadByForeignKey(Domain.class, "example.tld", clock.nowUtc()).get();
+        ForeignKeyUtils.loadResource(Domain.class, "example.tld", clock.nowUtc()).get();
    assertAboutHosts().that(host).hasSuperordinateDomain(superordinateDomain.createVKey());
    assertThat(superordinateDomain.getSubordinateHosts()).containsExactly("ns1.example.tld");
    assertHostDnsRequests("ns1.example.tld");
@@ -155,7 +156,7 @@ class HostCreateFlowTest extends ResourceFlowTestCase<HostCreateFlow, Host> {
    doSuccessfulInternalTest("tld");
    Host host = reloadResourceByForeignKey();
    Domain superordinateDomain =
-        loadByForeignKey(Domain.class, "example.tld", clock.nowUtc()).get();
+        ForeignKeyUtils.loadResource(Domain.class, "example.tld", clock.nowUtc()).get();
    assertAboutHosts().that(host).hasSuperordinateDomain(superordinateDomain.createVKey());
    assertThat(superordinateDomain.getSubordinateHosts()).containsExactly("ns1.example.tld");
    assertHostDnsRequests("ns1.example.tld");
@@ -269,9 +270,10 @@ class HostCreateFlowTest extends ResourceFlowTestCase<HostCreateFlow, Host> {
    setEppHostCreateInput(
        "ns1.example.tld",
        """
-            <host:addr ip="v4">192.0.2.2</host:addr>
-            <host:addr ip="v6">192.0.2.29</host:addr>
-            <host:addr ip="v6">1080:0:0:0:8:800:200C:417A</host:addr>""");
+        <host:addr ip="v4">192.0.2.2</host:addr>
+        <host:addr ip="v6">192.0.2.29</host:addr>
+        <host:addr ip="v6">1080:0:0:0:8:800:200C:417A</host:addr>\
+        """);
    EppException thrown = assertThrows(IpAddressVersionMismatchException.class, this::runFlow);
    assertAboutEppExceptions().that(thrown).marshalsToXml();
  }
--- a/core/src/test/java/google/registry/flows/host/HostUpdateFlowTest.java
+++ b/core/src/test/java/google/registry/flows/host/HostUpdateFlowTest.java
@@ -18,7 +18,6 @@ import static com.google.common.base.Strings.nullToEmpty;
 import static com.google.common.truth.Truth.assertThat;
 import static google.registry.dns.RefreshDnsOnHostRenameAction.PARAM_HOST_KEY;
 import static google.registry.dns.RefreshDnsOnHostRenameAction.QUEUE_HOST_RENAME;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.testing.DatabaseHelper.assertHostDnsRequests;
 import static google.registry.testing.DatabaseHelper.assertNoBillingEvents;
 import static google.registry.testing.DatabaseHelper.assertNoDnsRequests;
@@ -168,7 +167,8 @@ class HostUpdateFlowTest extends ResourceFlowTestCase<HostUpdateFlow, Host> {
    // should now return null.
    assertThat(reloadResourceByForeignKey()).isNull();
    // However, it should load correctly if we use the new name (taken from the xml).
-    Host renamedHost = loadByForeignKey(Host.class, "ns2.example.tld", clock.nowUtc()).get();
+    Host renamedHost =
+        ForeignKeyUtils.loadResource(Host.class, "ns2.example.tld", clock.nowUtc()).get();
    assertAboutHosts()
        .that(renamedHost)
        .hasOnlyOneHistoryEntryWhich()
--- a/core/src/test/java/google/registry/model/EppResourceTest.java
+++ b/core/src/test/java/google/registry/model/EppResourceTest.java
@@ -15,7 +15,6 @@
 package google.registry.model;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.testing.DatabaseHelper.persistActiveContact;
 import static google.registry.testing.DatabaseHelper.persistActiveHost;
 import static google.registry.testing.DatabaseHelper.persistResource;
@@ -44,7 +43,7 @@ public class EppResourceTest extends EntityTestCase {
        persistResource(originalContact.asBuilder().setEmailAddress("different@fake.lol").build());
    assertThat(EppResource.loadByCacheIfEnabled(ImmutableList.of(originalContact.createVKey())))
        .containsExactly(originalContact.createVKey(), originalContact);
-    assertThat(loadByForeignKey(Contact.class, "contact123", fakeClock.nowUtc()))
+    assertThat(ForeignKeyUtils.loadResource(Contact.class, "contact123", fakeClock.nowUtc()))
        .hasValue(modifiedContact);
  }

@@ -58,7 +57,7 @@ public class EppResourceTest extends EntityTestCase {
            originalHost.asBuilder().setLastTransferTime(fakeClock.nowUtc().minusDays(60)).build());
    assertThat(EppResource.loadByCacheIfEnabled(ImmutableList.of(originalHost.createVKey())))
        .containsExactly(originalHost.createVKey(), originalHost);
-    assertThat(loadByForeignKey(Host.class, "ns1.example.com", fakeClock.nowUtc()))
+    assertThat(ForeignKeyUtils.loadResource(Host.class, "ns1.example.com", fakeClock.nowUtc()))
        .hasValue(modifiedHost);
  }
 }
--- a/core/src/test/java/google/registry/model/OteStatsTestHelper.java
+++ b/core/src/test/java/google/registry/model/OteStatsTestHelper.java
@@ -195,9 +195,7 @@ public final class OteStatsTestHelper {

  private static Domain loadOrCreateDomain(String domainName) {
    return tm().transact(
-            () ->
-                EppResourceUtils.loadByForeignKey(
-                    Domain.class, domainName, tm().getTransactionTime()))
+            () -> ForeignKeyUtils.loadResource(Domain.class, domainName, tm().getTransactionTime()))
        .orElseGet(() -> persistActiveDomain(domainName));
  }
 }
--- a/core/src/test/java/google/registry/model/contact/ContactTest.java
+++ b/core/src/test/java/google/registry/model/contact/ContactTest.java
@@ -15,7 +15,6 @@
 package google.registry.model.contact;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.ImmutableObjectSubject.assertAboutImmutableObjects;
 import static google.registry.testing.ContactSubject.assertAboutContacts;
 import static google.registry.testing.DatabaseHelper.cloneAndSetAutoTimestamps;
@@ -29,6 +28,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import google.registry.model.EntityTestCase;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.contact.Disclose.PostalInfoChoice;
 import google.registry.model.contact.PostalInfo.Type;
 import google.registry.model.eppcommon.AuthInfo.PasswordAuth;
@@ -158,14 +158,17 @@ public class ContactTest extends EntityTestCase {

  @Test
  void testPersistence() {
-    assertThat(loadByForeignKey(Contact.class, contact.getForeignKey(), fakeClock.nowUtc()))
+    assertThat(
+            ForeignKeyUtils.loadResource(
+                Contact.class, contact.getForeignKey(), fakeClock.nowUtc()))
        .hasValue(contact);
  }

  @Test
  void testSerializable() {
    Contact persisted =
-        loadByForeignKey(Contact.class, contact.getForeignKey(), fakeClock.nowUtc()).get();
+        ForeignKeyUtils.loadResource(Contact.class, contact.getForeignKey(), fakeClock.nowUtc())
+            .get();
    assertThat(SerializeUtils.serializeDeserialize(persisted)).isEqualTo(persisted);
  }

--- a/core/src/test/java/google/registry/model/domain/DomainTest.java
+++ b/core/src/test/java/google/registry/model/domain/DomainTest.java
@@ -17,7 +17,6 @@ package google.registry.model.domain;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.Iterables.getOnlyElement;
 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.billing.BillingBase.RenewalPriceBehavior.SPECIFIED;
 import static google.registry.model.domain.token.AllocationToken.TokenType.BULK_PRICING;
 import static google.registry.model.domain.token.AllocationToken.TokenType.SINGLE_USE;
@@ -43,6 +42,7 @@ import com.google.common.collect.ImmutableSortedMap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Ordering;
 import com.google.common.collect.Streams;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.ImmutableObject;
 import google.registry.model.ImmutableObjectSubject;
 import google.registry.model.billing.BillingBase.Flag;
@@ -238,15 +238,17 @@ public class DomainTest {
    // Note that this only verifies that the value stored under the foreign key is the same as that
    // stored under the primary key ("domain" is the domain loaded from the the database, not the
    // original domain object).
-    assertThat(loadByForeignKey(Domain.class, domain.getForeignKey(), fakeClock.nowUtc()))
+    String foreignKey = domain.getForeignKey();
+    assertThat(ForeignKeyUtils.loadResource(Domain.class, foreignKey, fakeClock.nowUtc()))
        .hasValue(domain);
  }

  @Test
  void testRegistrantNotRequired() {
    persistResource(domain.asBuilder().setRegistrant(Optional.empty()).build());
+    String foreignKey = domain.getForeignKey();
    assertThat(
-            loadByForeignKey(Domain.class, domain.getForeignKey(), fakeClock.nowUtc())
+            ForeignKeyUtils.loadResource(Domain.class, foreignKey, fakeClock.nowUtc())
                .get()
                .getRegistrant())
        .isEmpty();
--- a/core/src/test/java/google/registry/testing/DatabaseHelper.java
+++ b/core/src/test/java/google/registry/testing/DatabaseHelper.java
@@ -61,7 +61,7 @@ import google.registry.dns.DnsUtils.TargetType;
 import google.registry.dns.writer.VoidDnsWriter;
 import google.registry.model.Buildable;
 import google.registry.model.EppResource;
-import google.registry.model.EppResourceUtils;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.ImmutableObject;
 import google.registry.model.billing.BillingBase;
 import google.registry.model.billing.BillingBase.Flag;
@@ -462,7 +462,7 @@ public final class DatabaseHelper {
                  .forEach(
                      hostname ->
                          deleteResource(
-                              EppResourceUtils.loadByForeignKey(Host.class, hostname, now).get()));
+                              ForeignKeyUtils.loadResource(Host.class, hostname, now).get()));
              for (HistoryEntry hist : historyEntries) {
                deleteResource(hist);
              }
--- a/core/src/test/java/google/registry/tools/EppLifecycleToolsTest.java
+++ b/core/src/test/java/google/registry/tools/EppLifecycleToolsTest.java
@@ -14,7 +14,6 @@

 package google.registry.tools;

-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.common.FeatureFlag.FeatureName.MINIMUM_DATASET_CONTACTS_OPTIONAL;
 import static google.registry.model.common.FeatureFlag.FeatureStatus.INACTIVE;
 import static google.registry.testing.DatabaseHelper.assertBillingEventsForResource;
@@ -28,6 +27,7 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedMap;
 import google.registry.flows.EppTestCase;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingBase.Reason;
 import google.registry.model.billing.BillingEvent;
 import google.registry.model.common.FeatureFlag;
@@ -157,7 +157,9 @@ class EppLifecycleToolsTest extends EppTestCase {
    // Assert about billing events.
    DateTime createTime = DateTime.parse("2000-06-01T00:02:00Z");
    Domain domain =
-        loadByForeignKey(Domain.class, "example.tld", DateTime.parse("2003-06-02T00:02:00Z")).get();
+        ForeignKeyUtils.loadResource(
+                Domain.class, "example.tld", DateTime.parse("2003-06-02T00:02:00Z"))
+            .get();
    BillingEvent renewBillingEvent =
        new BillingEvent.Builder()
            .setReason(Reason.RENEW)
--- a/core/src/test/java/google/registry/tools/UnrenewDomainCommandTest.java
+++ b/core/src/test/java/google/registry/tools/UnrenewDomainCommandTest.java
@@ -15,7 +15,6 @@
 package google.registry.tools;

 import static com.google.common.truth.Truth.assertThat;
-import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.model.eppcommon.StatusValue.PENDING_DELETE;
 import static google.registry.model.eppcommon.StatusValue.PENDING_TRANSFER;
 import static google.registry.model.reporting.HistoryEntry.Type.SYNTHETIC;
@@ -34,6 +33,7 @@ import static google.registry.testing.HistoryEntrySubject.assertAboutHistoryEntr
 import static org.junit.jupiter.api.Assertions.assertThrows;

 import com.google.common.collect.ImmutableSet;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.billing.BillingBase.Flag;
 import google.registry.model.billing.BillingBase.Reason;
 import google.registry.model.billing.BillingRecurrence;
@@ -81,12 +81,12 @@ public class UnrenewDomainCommandTest extends CommandTestCase<UnrenewDomainComma
    runCommandForced("-p", "2", "foo.tld", "bar.tld");
    fakeClock.disableAutoIncrement();
    assertThat(
-            loadByForeignKey(Domain.class, "foo.tld", fakeClock.nowUtc())
+            ForeignKeyUtils.loadResource(Domain.class, "foo.tld", fakeClock.nowUtc())
                .get()
                .getRegistrationExpirationTime())
        .isEqualTo(DateTime.parse("2019-12-06T13:55:01.001Z"));
    assertThat(
-            loadByForeignKey(Domain.class, "bar.tld", fakeClock.nowUtc())
+            ForeignKeyUtils.loadResource(Domain.class, "bar.tld", fakeClock.nowUtc())
                .get()
                .getRegistrationExpirationTime())
        .isEqualTo(DateTime.parse("2018-12-06T13:55:01.002Z"));
@@ -109,7 +109,7 @@ public class UnrenewDomainCommandTest extends CommandTestCase<UnrenewDomainComma
    runCommandForced("-p", "2", "foo.tld");
    DateTime unrenewTime = fakeClock.nowUtc();
    fakeClock.advanceOneMilli();
-    Domain domain = loadByForeignKey(Domain.class, "foo.tld", fakeClock.nowUtc()).get();
+    Domain domain = ForeignKeyUtils.loadResource(Domain.class, "foo.tld", fakeClock.nowUtc()).get();

    assertAboutHistoryEntries()
        .that(getOnlyHistoryEntryOfType(domain, SYNTHETIC))
--- a/core/src/test/java/google/registry/ui/server/console/ConsoleDomainListActionTest.java
+++ b/core/src/test/java/google/registry/ui/server/console/ConsoleDomainListActionTest.java
@@ -22,7 +22,7 @@ import static jakarta.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
 import static org.mockito.Mockito.when;

 import com.google.common.collect.Iterables;
-import google.registry.model.EppResourceUtils;
+import google.registry.model.ForeignKeyUtils;
 import google.registry.model.domain.Domain;
 import google.registry.request.Action;
 import google.registry.request.auth.AuthResult;
@@ -125,7 +125,7 @@ public class ConsoleDomainListActionTest extends ConsoleActionBaseTestCase {

    clock.advanceOneMilli();
    Domain toDelete =
-        EppResourceUtils.loadByForeignKey(Domain.class, "0exists.tld", clock.nowUtc()).get();
+        ForeignKeyUtils.loadResource(Domain.class, "0exists.tld", clock.nowUtc()).get();
    persistDomainAsDeleted(toDelete, clock.nowUtc());

    // Second page should include the domain that is now deleted due to the checkpoint time