solution: more flexible setup for credentials

Author: splix

emerald-api/src/main/java/io/emeraldpay/api/EmeraldConnection.java

@@ -72,8 +72,8 @@ public static class Builder {
         private Integer port;
         private boolean usePlaintext = false;
         private boolean useLoadBalancing = true;
-        private boolean autoConnect = false;
-        private boolean waitForAuth = false;
+        private EmeraldCredentials.Builder credentials = EmeraldCredentials.newBuilder();
+        private AuthInterceptor providedCredentials = null;
 
         /**
          * Default Netty config allows messages up to 4Mb, but in practice Ethereum RPC responses may be larger. Here it allows up to 32Mb by default.
@@ -82,8 +82,6 @@ public static class Builder {
 
         private Function<NettyChannelBuilder, ManagedChannelBuilder<?>> customChannel = null;
 
-        private String secretToken;
-
         /**
          * Set target address as a host and port pair
          *
@@ -152,7 +150,10 @@ public Builder disableLoadBalancing() {
          * @return builder
          */
         public Builder withAutoConnect() {
-            this.autoConnect = true;
+            if (providedCredentials != null) {
+                throw new IllegalStateException("Cannot set configure credentials builder when credentials are already provided");
+            }
+            this.credentials = this.credentials.withAutoConnect();
             return this;
         }
 
@@ -162,7 +163,10 @@ public Builder withAutoConnect() {
          * @return builder
          */
         public Builder withWaitingForAuth() {
-            this.waitForAuth = true;
+            if (providedCredentials != null) {
+                throw new IllegalStateException("Cannot set configure credentials builder when credentials are already provided");
+            }
+            this.credentials = this.credentials.withWaitingForAuth();
             return this;
         }
 
@@ -184,7 +188,38 @@ public Builder maxMessageSize(Integer value) {
          * @return builder
          */
         public Builder withAuthToken(String secret) {
-            this.secretToken = secret;
+            if (providedCredentials != null) {
+                throw new IllegalStateException("Cannot set auth token when credentials are already provided");
+            }
+            this.credentials = this.credentials.withAuthToken(secret);
+            return this;
+        }
+
+        /**
+         * Provided credentials builder.
+         * Replaces the existing credentials builder or previously configured credentials.
+         *
+         * @param credentials credentials builder to use for authentication
+         * @return builder
+         */
+        public Builder withCredentials(EmeraldCredentials.Builder credentials) {
+            if (credentials == null) {
+                throw new IllegalArgumentException("Credentials builder cannot be null");
+            }
+            this.credentials = credentials;
+            this.providedCredentials = null;
+            return this;
+        }
+
+        /**
+         * Set an existing credentials interceptor to use for authentication, instead of building new ones from the credentials builder.
+         * Can be set to null to use the credentials builder instead.
+         *
+         * @param credentials credentials interceptor to use for authentication
+         * @return builder
+         */
+        public Builder withCredentials(AuthInterceptor credentials) {
+            this.providedCredentials = credentials;
             return this;
         }
 
@@ -208,24 +243,6 @@ protected void initDefaults() {
             }
         }
 
-        /**
-         * Setup the credentials instance
-         *
-         * @param channel the existing channel to use for authentication
-         * @return credentials instance
-         */
-        protected TokenCredentials getOrCreateCredentials(Channel channel) {
-            TokenCredentials result = new TokenCredentials(secretToken, AuthGrpc.newBlockingStub(channel));
-            if (autoConnect) {
-                if (waitForAuth) {
-                    result.authSync();
-                } else {
-                    result.authAsync();
-                }
-            }
-            return result;
-        }
-
         /**
          * Build the API instance
          *
@@ -258,14 +275,14 @@ public EmeraldConnection build() {
             }
 
             Channel channel = channelBuilder.build();
-
-            AuthInterceptor authInterceptor = null;
-            if (secretToken != null) {
-                if (usePlaintext) {
-                    System.err.println("WARNING: Authentication with a secret token over an unsecure plaintext connection.");
+            AuthInterceptor authInterceptor = providedCredentials;
+            if (authInterceptor == null) {
+                if (credentials.hasToken()) {
+                    if (usePlaintext) {
+                        System.err.println("WARNING: Authentication with a secret token over an unsecure plaintext connection.");
+                    }
                 }
-                AuthHolder holder = new AuthHolder(getOrCreateCredentials(channel));
-                authInterceptor = new AuthInterceptor(holder);
+                authInterceptor = credentials.build(channel);
             }
 
             return new EmeraldConnection(channel, authInterceptor);

emerald-api/src/main/java/io/emeraldpay/api/EmeraldCredentials.java

@@ -0,0 +1,98 @@
+package io.emeraldpay.api;
+
+import io.emeraldpay.api.proto.AuthGrpc;
+import io.emeraldpay.impl.AuthHolder;
+import io.emeraldpay.impl.AuthInterceptor;
+import io.emeraldpay.impl.TokenCredentials;
+import io.grpc.Channel;
+
+/**
+ * Credentials configuration for Emerald API authentication
+ */
+public class EmeraldCredentials {
+
+    public static EmeraldCredentials.Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+        private boolean autoConnect = false;
+        private boolean waitForAuth = false;
+        private String secretToken;
+
+        /**
+         * Authenticate on Emerald API using the provided secret token
+         *
+         * @param secret a token like `emrld_y40SYbbZclSZPX4r6nL9hNKUGaknAwqyv2qslI`
+         * @return builder
+         */
+        public EmeraldCredentials.Builder withAuthToken(String secret) {
+            this.secretToken = secret;
+            return this;
+        }
+
+        /**
+         * Automatically authenticate on Emerald API when the connection is built.
+         * By default, it authenticates on the first request, which may cause delays.
+         *
+         * @return builder
+         */
+        public EmeraldCredentials.Builder withAutoConnect() {
+            this.autoConnect = true;
+            return this;
+        }
+
+        /**
+         * When auto-connect is enabled, wait for authentication to complete before returning the EmeraldConnection instance.
+         *
+         * @return builder
+         */
+        public EmeraldCredentials.Builder withWaitingForAuth() {
+            this.waitForAuth = true;
+            return this;
+        }
+
+        /**
+         * Setup the credentials instance
+         *
+         * @param channel the existing channel to use for authentication
+         * @return credentials instance
+         */
+        protected TokenCredentials getOrCreateCredentials(Channel channel) {
+            TokenCredentials result = new TokenCredentials(secretToken, AuthGrpc.newBlockingStub(channel));
+            if (autoConnect) {
+                if (waitForAuth) {
+                    result.authSync();
+                } else {
+                    result.authAsync();
+                }
+            }
+            return result;
+        }
+
+        /**
+         *
+         * @return true if the credentials are configured with a token, false otherwise
+         */
+        public boolean hasToken() {
+            return secretToken != null;
+        }
+
+        /**
+         * Build the authentication interceptor. It needs the Channel to setup the authentication. It can be the same Channel as the one used for actual requests.
+         *
+         * @param channel the [existing] channel to use for authentication
+         * @return an instance of the authentication interceptor, or null if no authentication is configured
+         */
+        public AuthInterceptor build(Channel channel) {
+            AuthInterceptor authInterceptor = null;
+            if (secretToken != null) {
+                AuthHolder holder = new AuthHolder(getOrCreateCredentials(channel));
+                authInterceptor = new AuthInterceptor(holder);
+            }
+            return authInterceptor;
+        }
+    }
+
+
+}