@multiplatform.one/wallet 7.7.2

package/src/main/java/com/bitspur/keycloak/siwe/SiweUtil.java

@@ -0,0 +1,599 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/SiweUtil.java
+ * Project: siwe-keycloak
+ * File Created: 20-01-2025 07:51:00
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 20-01-2025 18:57:32
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022 - 2025
+ */
+
+package com.bitspur.keycloak.siwe;
+
+import com.bitspur.keycloak.siwe.Errors.SiweKeycloakException;
+import com.bitspur.keycloak.siwe.authenticators.browser.SiweBrowserAuthenticatorFactory;
+import com.bitspur.keycloak.siwe.authenticators.directgrant.SiweDirectGrantAuthenticatorFactory;
+import com.bitspur.keycloak.siwe.jpa.nonce.SiweNonce;
+import com.bitspur.keycloak.siwe.jpa.wallet.SiweWalletAddress;
+import com.moonstoneid.siwe.error.SiweException;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.math.BigInteger;
+import java.net.URI;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.NoResultException;
+import jakarta.persistence.TypedQuery;
+import jakarta.ws.rs.core.Cookie;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriBuilder;
+
+import static org.keycloak.provider.ProviderConfigProperty.STRING_TYPE;
+import static org.keycloak.provider.ProviderConfigProperty.TEXT_TYPE;
+
+import org.jboss.logging.Logger;
+import org.keycloak.authentication.AuthenticationFlowContext;
+import org.keycloak.authentication.AuthenticationFlowError;
+import org.keycloak.authentication.authenticators.browser.AbstractUsernameFormAuthenticator;
+import org.keycloak.connections.jpa.JpaConnectionProvider;
+import org.keycloak.events.Details;
+import org.keycloak.events.Errors;
+import org.keycloak.forms.login.LoginFormsPages;
+import org.keycloak.forms.login.LoginFormsProvider;
+import org.keycloak.forms.login.freemarker.model.LoginBean;
+import org.keycloak.http.HttpRequest;
+import org.keycloak.models.AuthenticationExecutionModel;
+import org.keycloak.models.AuthenticationFlowModel;
+import org.keycloak.models.AuthenticatorConfigModel;
+import org.keycloak.models.KeycloakSession;
+import org.keycloak.models.ModelDuplicateException;
+import org.keycloak.models.RealmModel;
+import org.keycloak.models.UserModel;
+import org.keycloak.provider.ProviderConfigProperty;
+import org.keycloak.services.ServicesLogger;
+import org.keycloak.services.messages.Messages;
+import org.keycloak.theme.Theme;
+import org.keycloak.userprofile.UserProfile;
+import org.keycloak.userprofile.UserProfileContext;
+import org.keycloak.userprofile.UserProfileProvider;
+import org.keycloak.models.utils.KeycloakModelUtils;
+
+public class SiweUtil {
+  private static final String LOGIN_SIWE_PAGE = "login-siwe.ftl";
+
+  private static final Logger logger = Logger.getLogger(SiweUtil.class);
+
+  private static final SecureRandom random = new SecureRandom();
+
+  public static final String JSON_RPC_URL_CONFIG = "json_rpc_url";
+
+  public static final String REQUIRED_TOKENS_CONFIG = "required_tokens";
+
+  public static final String SIWE_ADDRESSES_ATTRIBUTE = "SIWE_ADDRESSES";
+
+  public static final String KEYCLOAK_SESSION_SIWE = "KEYCLOAK_SESSION_SIWE";
+
+  public static final String DEFAULT_ADDRESS_TYPE = "ethereum";
+
+  public static final String DEFAULT_JSON_RPC_URL = (System.getenv("DEFAULT_JSON_RPC_URL") != null
+      && !System.getenv("DEFAULT_JSON_RPC_URL").isEmpty())
+          ? System.getenv("DEFAULT_JSON_RPC_URL")
+          : "https://cloudflare-eth.com";
+
+  public static UserModel findOrCreateUser(AuthenticationFlowContext context,
+      SiweCredentials siweCredentials) throws SiweKeycloakException {
+    return SiweUtil.findOrCreateUser(context, siweCredentials, true);
+  }
+
+  public static UserModel findOrCreateUser(AuthenticationFlowContext context,
+      SiweCredentials siweCredentials,
+      Boolean failureChallenge) throws SiweKeycloakException {
+    String address = siweCredentials.message.getAddress();
+    if (address == null) {
+      if (failureChallenge) {
+        context.getEvent().error(Errors.USER_NOT_FOUND);
+        LoginFormsProvider form = context.form();
+        form.setExecution(context.getExecution().getId());
+        form.setError(Messages.INVALID_USER);
+        context.failureChallenge(AuthenticationFlowError.INVALID_USER, form.createLoginUsernamePassword());
+      }
+      return null;
+    }
+    UserModel user = null;
+    EntityManager entityManager = context.getSession().getProvider(JpaConnectionProvider.class).getEntityManager();
+    try {
+      List<SiweWalletAddress> wallets = entityManager
+          .createNamedQuery("findByRealmAddressType", SiweWalletAddress.class)
+          .setParameter("realmId", context.getRealm().getId())
+          .setParameter("address", address.toLowerCase().trim())
+          .setParameter("addressType", SiweUtil.DEFAULT_ADDRESS_TYPE)
+          .getResultList();
+      if (!wallets.isEmpty()) {
+        user = context.getSession().users().getUserById(context.getRealm(), wallets.get(0).getUserId());
+      }
+    } catch (ModelDuplicateException mde) {
+      if (failureChallenge) {
+        ServicesLogger.LOGGER.modelDuplicateException(mde);
+        context.getEvent().error(Errors.USERNAME_IN_USE);
+        LoginFormsProvider form = context.form();
+        form.setError(Messages.USERNAME_EXISTS);
+        context.failureChallenge(AuthenticationFlowError.INVALID_USER, SiweUtil.createLoginSiwePage(form));
+      }
+      return null;
+    }
+    if (user == null) {
+      if (SiweUtil.verifySiweCredentials(context.getSession(), context.getAuthenticatorConfig(), siweCredentials)
+          && SiweUtil.verifyHasRequiredTokens(context.getSession(), context.getAuthenticatorConfig(),
+              siweCredentials)) {
+        KeycloakSession session = context.getSession();
+        UserProfileProvider profileProvider = session.getProvider(UserProfileProvider.class);
+        MultivaluedMap<String, String> formData = new MultivaluedHashMap<>();
+        String username = generateRandomUsername(session, context.getRealm());
+        context.getEvent().detail(Details.USERNAME, username);
+        context.getAuthenticationSession().setAuthNote(AbstractUsernameFormAuthenticator.ATTEMPTED_USERNAME, username);
+        formData.add("username", username);
+        UserProfile profile = profileProvider.create(UserProfileContext.REGISTRATION, formData);
+        user = profile.create();
+        user.setEnabled(true);
+        SiweWalletAddress wallet = new SiweWalletAddress();
+        wallet.setAddress(address.toLowerCase().trim());
+        wallet.setAddressType(SiweUtil.DEFAULT_ADDRESS_TYPE);
+        wallet.setUserId(user.getId());
+        wallet.setRealmId(context.getRealm().getId());
+        entityManager.persist(wallet);
+        return user;
+      }
+      if (failureChallenge) {
+        context.getEvent().error(Errors.USER_NOT_FOUND);
+        LoginFormsProvider form = context.form();
+        form.setExecution(context.getExecution().getId());
+        form.setError(Messages.INVALID_USER);
+        context.failureChallenge(AuthenticationFlowError.INVALID_USER, SiweUtil.createLoginSiwePage(form));
+      }
+      return null;
+    }
+    String username = user.getUsername();
+    context.getEvent().detail(Details.USERNAME, username);
+    context.getAuthenticationSession().setAuthNote(AbstractUsernameFormAuthenticator.ATTEMPTED_USERNAME, username);
+    return user;
+  }
+
+  public static ProviderConfigProperty getRequiredTokensConfigProperty() {
+    ProviderConfigProperty property = new ProviderConfigProperty();
+    property.setType(TEXT_TYPE);
+    property.setName(SiweUtil.REQUIRED_TOKENS_CONFIG);
+    property.setLabel("required tokens");
+    property.setHelpText("Expects a list of smart contract addresses. "
+        + "The minium number of tokens required can be specified by appending a colon and "
+        + "the number of tokens required at the end of the address. For example: "
+        + "0x1234567890123456789012345678901234567890:10");
+    return property;
+  }
+
+  public static ProviderConfigProperty getJsonRpcUrlConfigProperty() {
+    ProviderConfigProperty property = new ProviderConfigProperty();
+    property.setType(STRING_TYPE);
+    property.setName(SiweUtil.JSON_RPC_URL_CONFIG);
+    property.setLabel("json rpc url");
+    property.setDefaultValue(SiweUtil.DEFAULT_JSON_RPC_URL);
+    return property;
+  }
+
+  public static Response createResponse(LoginFormsProvider form, String template) {
+    return SiweUtil.createResponse(form, template, null);
+  }
+
+  public static Response createLoginSiwePage(LoginFormsProvider form) {
+    return SiweUtil.createResponse(form, SiweUtil.LOGIN_SIWE_PAGE, LoginFormsPages.LOGIN);
+  }
+
+  public static String getJsonRpcUrl(AuthenticatorConfigModel configModel) {
+    try {
+      Map<String, String> config = configModel.getConfig();
+      String jsonRpcUrl = config.get(SiweUtil.JSON_RPC_URL_CONFIG);
+      if (jsonRpcUrl == null || jsonRpcUrl.length() <= 0) {
+        return null;
+      }
+      return jsonRpcUrl;
+    } catch (NullPointerException e) {
+    }
+    return null;
+  }
+
+  public static List<Token> getRequiredTokens(AuthenticatorConfigModel configModel) {
+    String jsonRpcUrl = SiweUtil.getJsonRpcUrl(configModel);
+    if (jsonRpcUrl == null || jsonRpcUrl.length() <= 0) {
+      return null;
+    }
+    try {
+      List<Token> requiredTokens = new ArrayList<Token>();
+      Map<String, String> config = configModel.getConfig();
+      String requiredTokensStr = config.get(SiweUtil.REQUIRED_TOKENS_CONFIG);
+      if (requiredTokensStr == null || requiredTokensStr.length() <= 0) {
+        return null;
+      }
+      String[] requiredTokensArr = requiredTokensStr.split("[,\n]+");
+      for (Integer i = 0; i < requiredTokensArr.length; i++) {
+        String[] requiredTokenArr = requiredTokensArr[0].split(":");
+        BigInteger requiredBalanceOf = BigInteger.valueOf(1);
+        String contractAddress = requiredTokenArr[0];
+        if (contractAddress.length() <= 0) {
+          continue;
+        }
+        if (requiredTokenArr.length > 1) {
+          try {
+            requiredBalanceOf = new BigInteger(requiredTokenArr[1]);
+          } catch (NumberFormatException e) {
+          }
+        }
+        requiredTokens.add(new Token(contractAddress, jsonRpcUrl, requiredBalanceOf));
+      }
+      if (requiredTokens.size() <= 0) {
+        return null;
+      }
+      return requiredTokens;
+    } catch (NullPointerException e) {
+    }
+    return null;
+  }
+
+  public static SiweSession generateSiweSession(KeycloakSession session) {
+    String nonce = SiweUtil.generateNonce();
+    String sessionKey = SiweUtil.generateSessionKey(session.getContext().getRealm().getName());
+    SiweUtil.setNonce(session, sessionKey, nonce);
+    return new SiweSession(sessionKey, nonce);
+  }
+
+  public static AuthenticatorConfigModel getAuthenticatorConfig(KeycloakSession session, Boolean isDirectGrantFlow) {
+    RealmModel realm = session.getContext().getRealm();
+    AuthenticationFlowModel flow = realm.getBrowserFlow();
+    if (isDirectGrantFlow) {
+      flow = realm.getDirectGrantFlow();
+    }
+    AuthenticationExecutionModel execution = realm.getAuthenticationExecutionsStream(flow.getId())
+        .filter(e -> {
+          String authenticator = e.getAuthenticator();
+          return authenticator != null
+              && authenticator.equals(isDirectGrantFlow ? SiweDirectGrantAuthenticatorFactory.ID
+                  : SiweBrowserAuthenticatorFactory.ID);
+        })
+        .findFirst().orElse(null);
+    if (execution == null) {
+      return null;
+    }
+    return realm.getAuthenticatorConfigById(execution.getAuthenticatorConfig());
+  }
+
+  public static String getSessionKey(KeycloakSession session) throws SiweKeycloakException {
+    HttpRequest request = session.getContext().getHttpRequest();
+    Cookie cookie = request.getHttpHeaders().getCookies().get(SiweUtil.KEYCLOAK_SESSION_SIWE);
+    String sessionKey = null;
+    if (cookie != null) {
+      sessionKey = cookie.getValue();
+    }
+    if (sessionKey == null) {
+      throw new SiweKeycloakException("missing siwe session");
+    }
+    return sessionKey;
+  }
+
+  public static String getNonce(KeycloakSession session) throws SiweKeycloakException {
+    String sessionKey = SiweUtil.getSessionKey(session);
+    return SiweUtil.getNonce(session, sessionKey);
+  }
+
+  public static String getNonce(KeycloakSession session, String key) {
+    SiweNonce siweNonce = SiweUtil.getSiweNonce(session, key);
+    if (siweNonce == null) {
+      return null;
+    }
+    return siweNonce.getNonce();
+  }
+
+  public static String setNonce(KeycloakSession session, String key, String nonce) {
+    RealmModel realm = session.getContext().getRealm();
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    SiweNonce siweNonce = SiweUtil.getSiweNonce(session, key);
+    if (siweNonce == null) {
+      siweNonce = new SiweNonce();
+      siweNonce.setKey(key);
+      siweNonce.setRealmId(realm.getId());
+    }
+    siweNonce.setNonce(nonce);
+    entityManager.merge(siweNonce);
+    return nonce;
+  }
+
+  public static Void removeNonce(KeycloakSession session, String key) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    SiweNonce siweNonce = SiweUtil.getSiweNonce(session, key);
+    if (siweNonce == null) {
+      return null;
+    }
+    entityManager.remove(siweNonce);
+    return null;
+  }
+
+  public static Map<String, String> getNonces(KeycloakSession session) {
+    RealmModel realm = session.getContext().getRealm();
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    Map<String, String> nonces = new HashMap<>();
+    entityManager.createNamedQuery("findByRealm", SiweNonce.class)
+        .setParameter("realmId", realm.getId())
+        .getResultList().stream().forEach((nonce) -> {
+          nonces.put(nonce.getKey(), nonce.getNonce());
+        });
+    return nonces;
+  }
+
+  public static Boolean verify(
+      KeycloakSession session, AuthenticatorConfigModel configModel,
+      SiweCredentials siweCredentials)
+      throws SiweKeycloakException {
+    return SiweUtil.verifyExistingUser(session, configModel, siweCredentials)
+        && SiweUtil.verifySiweCredentials(session, configModel, siweCredentials) &&
+        SiweUtil.verifyHasRequiredTokens(session, configModel, siweCredentials);
+  }
+
+  public static Boolean verifyExistingUser(
+      KeycloakSession session,
+      AuthenticatorConfigModel configModel, SiweCredentials siweCredentials)
+      throws SiweKeycloakException {
+    String address = siweCredentials.message.getAddress().toLowerCase().trim();
+    RealmModel realm = session.getContext().getRealm();
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    List<SiweWalletAddress> wallets = entityManager
+        .createNamedQuery("findByRealmAddressType", SiweWalletAddress.class)
+        .setParameter("realmId", realm.getId())
+        .setParameter("address", address)
+        .setParameter("addressType", SiweUtil.DEFAULT_ADDRESS_TYPE)
+        .getResultList();
+    return !wallets.isEmpty();
+  }
+
+  public static Boolean verifySiweCredentials(KeycloakSession session,
+      AuthenticatorConfigModel configModel, SiweCredentials siweCredentials)
+      throws SiweKeycloakException {
+    HttpRequest httpRequest = session.getContext().getHttpRequest();
+    URI requestUri = httpRequest.getUri().getRequestUri();
+    String domain = requestUri.getHost();
+    Integer port = requestUri.getPort();
+    String scheme = requestUri.getScheme();
+    if (port != -1 && !(scheme.equals("http") && port == 80) && !(scheme.equals("https") && port == 443)) {
+      domain += ":" + port;
+    }
+    // TODO: temporary fix for cross domains
+    domain = siweCredentials.message.getDomain();
+    String nonce = SiweUtil.getNonce(session);
+    if (nonce == null) {
+      return false;
+    }
+    try {
+      siweCredentials.message.verify(domain, nonce, siweCredentials.signature);
+      return true;
+    } catch (SiweException e) {
+      throw new SiweKeycloakException(e.getMessage());
+    }
+  }
+
+  public static Boolean verifyHasRequiredTokens(KeycloakSession session,
+      AuthenticatorConfigModel configModel, SiweCredentials siweCredentials) {
+    List<Token> tokens = SiweUtil.getRequiredTokens(configModel);
+    if (tokens == null || tokens.size() <= 0) {
+      return true;
+    }
+    for (Integer i = 0; i < tokens.size(); i++) {
+      Token token = tokens.get(i);
+      if (!token.hasRequiredBalanceOf(siweCredentials.message.getAddress())) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  protected static SiweNonce getSiweNonce(KeycloakSession session, String key) {
+    RealmModel realm = session.getContext().getRealm();
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    SiweNonce siweNonce = entityManager.createNamedQuery("findByRealmKey", SiweNonce.class)
+        .setParameter("key", key)
+        .setParameter("realmId", realm.getId())
+        .getResultList().stream().findFirst().orElse(null);
+    return siweNonce;
+  }
+
+  // https://github.com/keycloak/keycloak/blob/8b7a0b357ac1c6e7b74460312e231fc785b885b1/services/src/main/java/org/keycloak/forms/login/freemarker/FreeMarkerLoginFormsProvider.java#L220
+  protected static Response createResponse(LoginFormsProvider form, String template, LoginFormsPages page) {
+    KeycloakSession session = null;
+    try {
+      Field sessionField = form.getClass().getDeclaredField("session");
+      sessionField.setAccessible(true);
+      session = (KeycloakSession) sessionField.get(form);
+      Method getTheme = form.getClass().getDeclaredMethod("getTheme");
+      getTheme.setAccessible(true);
+      Theme theme;
+      try {
+        theme = session.theme().getTheme(Theme.Type.LOGIN);
+      } catch (IOException e) {
+        logger.error("Failed to create theme", e);
+        return Response.serverError().build();
+      }
+      Field userField = form.getClass().getDeclaredField("user");
+      userField.setAccessible(true);
+      UserModel user = (UserModel) userField.get(form);
+      Method handleThemeResourcesMethod = form.getClass().getDeclaredMethod("handleThemeResources", Theme.class,
+          Locale.class);
+      handleThemeResourcesMethod.setAccessible(true);
+      Method handleMessagesMethod = form.getClass().getDeclaredMethod("handleMessages", Locale.class, Properties.class);
+      handleMessagesMethod.setAccessible(true);
+      Locale locale = session.getContext().resolveLocale(user);
+      Properties messagesBundle = (Properties) handleThemeResourcesMethod.invoke(form, theme, locale);
+      handleMessagesMethod.invoke(form, locale, messagesBundle);
+      Method prepareBaseUriBuilderMethod = form.getClass().getDeclaredMethod("prepareBaseUriBuilder", boolean.class);
+      prepareBaseUriBuilderMethod.setAccessible(true);
+      Method createCommonAttributesMethod = form.getClass().getDeclaredMethod("createCommonAttributes", Theme.class,
+          Locale.class, Properties.class, UriBuilder.class, LoginFormsPages.class);
+      createCommonAttributesMethod.setAccessible(true);
+      UriBuilder uriBuilder = (UriBuilder) prepareBaseUriBuilderMethod.invoke(form, false);
+      createCommonAttributesMethod.invoke(form, theme, locale, messagesBundle, uriBuilder, page);
+      Field attributesField = form.getClass().getDeclaredField("attributes");
+      attributesField.setAccessible(true);
+      @SuppressWarnings("unchecked")
+      Map<String, Object> attributes = (Map<String, Object>) attributesField.get(form);
+      Field formDataField = form.getClass().getDeclaredField("formData");
+      formDataField.setAccessible(true);
+      @SuppressWarnings("unchecked")
+      MultivaluedMap<String, String> formData = (MultivaluedMap<String, String>) formDataField.get(form);
+      attributes.put("login", new LoginBean(formData));
+      Field statusField = form.getClass().getDeclaredField("status");
+      statusField.setAccessible(true);
+      Response.Status status = (Response.Status) statusField.get(form);
+      if (status != null) {
+        attributes.put("statusCode", status.getStatusCode());
+      }
+      Method processTemplateMethod = form.getClass().getDeclaredMethod("processTemplate", Theme.class, String.class,
+          Locale.class);
+      processTemplateMethod.setAccessible(true);
+      Response response = (Response) processTemplateMethod.invoke(form, theme, template, locale);
+      return response;
+    } catch (Exception e) {
+      logger.error(e);
+      return null;
+    } finally {
+      if (session != null) {
+        session.close();
+      }
+    }
+  }
+
+  private static String generateNonce() {
+    return Base64.getUrlEncoder().withoutPadding().encodeToString(random.generateSeed(8))
+        .replaceAll("[^A-Za-z0-9]", "0")
+        .substring(0, 8);
+  }
+
+  private static String generateSessionKey(String realmName) {
+    byte[] keyBytes = new byte[32];
+    random.nextBytes(keyBytes);
+    return realmName + "/" + (Base64.getEncoder().encodeToString(keyBytes));
+  }
+
+  private static String generateRandomUsername(KeycloakSession session, RealmModel realm) {
+    while (true) {
+      String username = String.format("%010d", Math.abs(random.nextLong() % 10000000000L));
+      if (KeycloakModelUtils.findUserByNameOrEmail(session, realm, username) == null) {
+        return username;
+      }
+    }
+  }
+
+  public static Map<String, List<String>> getWalletsByType(KeycloakSession session, UserModel user) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    List<SiweWalletAddress> wallets = entityManager
+        .createNamedQuery("findByUserId", SiweWalletAddress.class)
+        .setParameter("userId", user.getId())
+        .getResultList();
+    Map<String, List<String>> walletsByType = new HashMap<>();
+    for (SiweWalletAddress wallet : wallets) {
+      String type = wallet.getAddressType();
+      if (!walletsByType.containsKey(type)) {
+        walletsByType.put(type, new ArrayList<>());
+      }
+      walletsByType.get(type).add(wallet.getAddress());
+    }
+    return walletsByType;
+  }
+
+  public static void addWalletsToToken(KeycloakSession session, UserModel user, Map<String, Object> token) {
+    Map<String, List<String>> walletsByType = getWalletsByType(session, user);
+    Map<String, Object> crypto = new HashMap<>();
+    Map<String, Object> wallets = new HashMap<>();
+    for (Map.Entry<String, List<String>> entry : walletsByType.entrySet()) {
+      Map<String, Object> typeInfo = new HashMap<>();
+      typeInfo.put("addresses", entry.getValue());
+      wallets.put(entry.getKey(), typeInfo);
+    }
+    crypto.put("wallets", wallets);
+    token.put("crypto", crypto);
+  }
+
+  public static UserModel findUserByWalletAddress(KeycloakSession session, String address) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    try {
+      TypedQuery<SiweWalletAddress> query = entityManager.createNamedQuery("findByRealmAddressType",
+          SiweWalletAddress.class);
+      query.setParameter("address", address.toLowerCase().trim());
+      query.setParameter("realmId", session.getContext().getRealm().getId());
+      query.setParameter("addressType", SiweUtil.DEFAULT_ADDRESS_TYPE);
+      List<SiweWalletAddress> wallets = query.getResultList();
+      if (!wallets.isEmpty()) {
+        return session.users().getUserById(session.getContext().getRealm(), wallets.get(0).getUserId());
+      }
+      return null;
+    } catch (NoResultException e) {
+      return null;
+    }
+  }
+
+  public static boolean addWalletAddress(KeycloakSession session, UserModel user, String address) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    TypedQuery<SiweWalletAddress> query = entityManager.createNamedQuery("findByRealmAddressType",
+        SiweWalletAddress.class);
+    query.setParameter("address", address.toLowerCase().trim());
+    query.setParameter("realmId", session.getContext().getRealm().getId());
+    query.setParameter("addressType", SiweUtil.DEFAULT_ADDRESS_TYPE);
+    List<SiweWalletAddress> existingWallets = query.getResultList();
+    for (SiweWalletAddress wallet : existingWallets) {
+      if (wallet.getUserId().equals(user.getId())) {
+        return false;
+      }
+    }
+    SiweWalletAddress wallet = new SiweWalletAddress();
+    wallet.setAddress(address.toLowerCase().trim());
+    wallet.setAddressType(SiweUtil.DEFAULT_ADDRESS_TYPE);
+    wallet.setUserId(user.getId());
+    wallet.setRealmId(session.getContext().getRealm().getId());
+    entityManager.persist(wallet);
+    return true;
+  }
+
+  public static List<SiweWalletAddress> getWalletAddresses(KeycloakSession session, UserModel user) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    TypedQuery<SiweWalletAddress> query = entityManager.createNamedQuery("findByUserId", SiweWalletAddress.class);
+    query.setParameter("userId", user.getId());
+    query.setParameter("realmId", session.getContext().getRealm().getId());
+    return query.getResultList();
+  }
+
+  public static boolean removeWalletAddress(KeycloakSession session, String address) {
+    EntityManager entityManager = session.getProvider(JpaConnectionProvider.class).getEntityManager();
+    TypedQuery<SiweWalletAddress> query = entityManager.createNamedQuery("findByRealmAddressType",
+        SiweWalletAddress.class);
+    query.setParameter("address", address.toLowerCase().trim());
+    query.setParameter("realmId", session.getContext().getRealm().getId());
+    query.setParameter("addressType", SiweUtil.DEFAULT_ADDRESS_TYPE);
+    try {
+      List<SiweWalletAddress> wallets = query.getResultList();
+      if (!wallets.isEmpty()) {
+        entityManager.remove(wallets.get(0));
+        return true;
+      }
+      return false;
+    } catch (NoResultException e) {
+      return false;
+    }
+  }
+}

package/src/main/java/com/bitspur/keycloak/siwe/Token.java

@@ -0,0 +1,85 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/Token.java
+ * Project: authenticators
+ * File Created: 29-03-2022 00:41:18
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 10-08-2023 16:34:52
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022
+ */
+
+package com.bitspur.keycloak.siwe;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import org.jboss.logging.Logger;
+
+import org.web3j.abi.FunctionEncoder;
+import org.web3j.abi.FunctionReturnDecoder;
+import org.web3j.abi.TypeReference;
+import org.web3j.abi.datatypes.Function;
+import org.web3j.abi.datatypes.Uint;
+import org.web3j.abi.datatypes.Address;
+import org.web3j.protocol.Web3j;
+import org.web3j.protocol.core.DefaultBlockParameterName;
+import org.web3j.protocol.core.methods.request.Transaction;
+import org.web3j.protocol.http.HttpService;
+
+public class Token {
+  private static final Logger logger = Logger.getLogger(Token.class);
+
+  private String contractAddress;
+
+  private Web3j web3j;
+
+  private String jsonRpcUrl;
+
+  private BigInteger requiredBalanceOf;
+
+  Token(String contractAddress, String jsonRpcUrl, BigInteger requiredBalanceOf) {
+    this.contractAddress = contractAddress;
+    this.jsonRpcUrl = jsonRpcUrl;
+    this.web3j = Web3j.build(new HttpService(jsonRpcUrl));
+    this.requiredBalanceOf = requiredBalanceOf;
+  }
+
+  Token(String contractAddress, String jsonRpcUrl) {
+    this.contractAddress = contractAddress;
+    this.jsonRpcUrl = jsonRpcUrl;
+    this.web3j = Web3j.build(new HttpService(jsonRpcUrl));
+    this.requiredBalanceOf = BigInteger.valueOf(1);
+  }
+
+  public Boolean hasRequiredBalanceOf(String address) {
+    return this.balanceOf(address).compareTo(this.requiredBalanceOf) >= 0;
+  }
+
+  public BigInteger balanceOf(String address) {
+    if (this.jsonRpcUrl == null || this.jsonRpcUrl.length() <= 0) {
+      return BigInteger.ZERO;
+    }
+    Function function = new Function("balanceOf", Arrays.asList(new Address(address)),
+        Arrays.asList(new TypeReference<Uint>() {
+        }));
+    String encodedFunction = FunctionEncoder.encode(function);
+    try {
+      List<?> result = FunctionReturnDecoder.decode(this.web3j.ethCall(
+          Transaction.createEthCallTransaction(address, this.contractAddress, encodedFunction),
+          DefaultBlockParameterName.LATEST).sendAsync().get().getValue(), function.getOutputParameters());
+      if (result.size() <= 0) {
+        return BigInteger.ZERO;
+      }
+      return ((Uint) result.get(0)).getValue();
+    } catch (InterruptedException e) {
+      logger.error(e);
+    } catch (ExecutionException e) {
+      logger.error(e);
+    }
+    return BigInteger.ZERO;
+  }
+}