chore: added debug for token fetching.

Author: Mateusz Czeladka

.env.docker-compose

@@ -114,7 +114,16 @@ PEER_DISCOVERY=false
 ## Token Registry
 # Token registry is enabled for mainnet
 TOKEN_REGISTRY_ENABLED=true
-TOKEN_REGISTRY_BASE_URL=https://tokens.cardano.org/api
+#TOKEN_REGISTRY_BASE_URL=https://tokens.cardano.org/api
 TOKEN_REGISTRY_CACHE_TTL_HOURS=12
 TOKEN_REGISTRY_LOGO_FETCH=false
 TOKEN_REGISTRY_REQUEST_TIMEOUT_SECONDS=2
+
+  # For testing only - disable SSL verification
+  cardano.rosetta.HTTP_SSL_VERIFY=false
+
+  # Use IP address instead of hostname
+  cardano.rosetta.TOKEN_REGISTRY_BASE_URL=https://35.158.243.250:30443/api
+
+  # Keep the Host header pointing to the actual hostname
+  cardano.rosetta.TOKEN_REGISTRY_HOST=tokens.cardano.org

api/src/main/java/org/cardanofoundation/rosetta/RosettaApiApplication.java

@@ -33,6 +33,8 @@
 public class RosettaApiApplication {
 
   public static void main(String[] args) {
+    System.setProperty("jdk.httpclient.allowRestrictedHeaders", "host");
+
     SpringApplication.run(RosettaApiApplication.class, args);
   }
 

api/src/main/java/org/cardanofoundation/rosetta/client/CachingTokenRegistryHttpGatewayImpl.java

@@ -39,6 +39,9 @@ public class CachingTokenRegistryHttpGatewayImpl implements TokenRegistryHttpGat
     @Value("${cardano.rosetta.TOKEN_REGISTRY_BASE_URL:https://tokens.cardano.org/api}")
     protected String tokenRegistryBaseUrl;
 
+    @Value("${cardano.rosetta.TOKEN_REGISTRY_HOST:tokens.cardano.org}")
+    protected String tokenRegistryHost;
+
     @Value("${cardano.rosetta.TOKEN_REGISTRY_REQUEST_TIMEOUT_SECONDS:2}") // aggressive timeout as we do not want to block the request
     protected int httpRequestTimeoutSeconds;
 
@@ -65,6 +68,9 @@ public Map<String, Optional<TokenSubject>> getTokenMetadataBatch(@NonNull Set<St
             return Collections.emptyMap();
         }
 
+
+        
+
         // Check cache for existing entries
         Set<String> subjectsToFetch = new HashSet<>();
         Map<String, Optional<TokenSubject>> result = new HashMap<>();
@@ -88,8 +94,7 @@ public Map<String, Optional<TokenSubject>> getTokenMetadataBatch(@NonNull Set<St
             return result;
         }
 
-        log.info("Initiating remote token registry HTTP POST request: {} for {} subjects", batchEndpointUrl, subjectsToFetch.size());
-        log.debug("Subjects to fetch from token registry: {}", subjectsToFetch);
+        log.info("Initiating remote token registry HTTP POST request: {} for {} subjects: {}", batchEndpointUrl, subjectsToFetch.size(), subjectsToFetch);
 
         Stopwatch stopwatch = Stopwatch.createStarted();
 
@@ -102,13 +107,16 @@ public Map<String, Optional<TokenSubject>> getTokenMetadataBatch(@NonNull Set<St
 
             // Prepare HTTP request
             String requestBody = objectMapper.writeValueAsString(request);
+            int requestBodyBytes = requestBody.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
+            log.info("HTTP POST request body size: {} bytes ({} KB)", requestBodyBytes, String.format("%.2f", requestBodyBytes / 1024.0));
 
             HttpRequest httpRequest = HttpRequest.newBuilder()
                     .uri(URI.create(batchEndpointUrl))
                     .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                     .timeout(Duration.ofSeconds(httpRequestTimeoutSeconds))
                     .header("Content-Type", "application/json")
                     .header("Accept", "application/json")
+                    .header("Host", tokenRegistryHost)
                     .build();
 
             // Execute request
@@ -127,12 +135,16 @@ public Map<String, Optional<TokenSubject>> getTokenMetadataBatch(@NonNull Set<St
             TokenRegistryBatchResponse batchResponse = objectMapper.readValue(response.body(), TokenRegistryBatchResponse.class);
 
             if (batchResponse.getSubjects() != null) {
+                List<String> receivedSubjects = new ArrayList<>();
                 for (TokenSubject tokenSubject : batchResponse.getSubjects()) {
                     // If subject is in response, cache it as found
                     result.put(tokenSubject.getSubject(), Optional.of(tokenSubject));
                     tokenMetadataCache.put(tokenSubject.getSubject(), TokenCacheEntry.found(tokenSubject));
-                    log.debug("Cached token metadata for subject: {}", tokenSubject.getSubject());
+                    receivedSubjects.add(tokenSubject.getSubject());
                 }
+                log.info("Token registry returned {} subjects: {}", receivedSubjects.size(), receivedSubjects);
+            } else {
+                log.info("Token registry returned no subjects");
             }
 
             // Cache empty results for subjects that were requested but not found in the response

api/src/main/java/org/cardanofoundation/rosetta/config/HttpConfig.java

@@ -1,27 +1,69 @@
 package org.cardanofoundation.rosetta.config;
 
 import java.net.http.HttpClient;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
 import java.time.Duration;
 import java.util.concurrent.Executors;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
 
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
+@Slf4j
 public class HttpConfig {
 
     @Value("${cardano.rosetta.HTTP_CONNECT_TIMEOUT_SECONDS}")
     private int httpConnectTimeoutSeconds;
 
+    @Value("${cardano.rosetta.HTTP_SSL_VERIFY:true}")
+    private boolean sslVerify;
+
     @Bean
     public HttpClient httpClient() {
-        return HttpClient.newBuilder()
+        HttpClient.Builder builder = HttpClient.newBuilder()
                 .version(HttpClient.Version.HTTP_2)
                 .followRedirects(HttpClient.Redirect.NORMAL)
                 .connectTimeout(Duration.ofSeconds(httpConnectTimeoutSeconds))
-                .executor(Executors.newVirtualThreadPerTaskExecutor())
-                .build();
+                .executor(Executors.newVirtualThreadPerTaskExecutor());
+
+        // For testing only - disable SSL verification if configured
+        if (!sslVerify) {
+            log.warn("SSL verification is DISABLED - this should only be used for testing!");
+            try {
+                SSLContext sslContext = SSLContext.getInstance("TLS");
+                sslContext.init(null, new TrustManager[]{new InsecureTrustManager()}, new java.security.SecureRandom());
+                builder.sslContext(sslContext);
+            } catch (NoSuchAlgorithmException | KeyManagementException e) {
+                log.error("Failed to create insecure SSL context", e);
+            }
+        }
+
+        return builder.build();
+    }
+
+    // Trust manager that accepts all certificates - FOR TESTING ONLY
+    private static class InsecureTrustManager implements X509TrustManager {
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain, String authType) {
+            // Accept all
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain, String authType) {
+            // Accept all
+        }
+
+        @Override
+        public X509Certificate[] getAcceptedIssuers() {
+            return new X509Certificate[0];
+        }
     }
 
 }