@openzeppelin/ui-builder-adapter-stellar 1.1.0 → 1.1.2

package/dist/index.js

@@ -3328,15 +3328,81 @@ import {
   IndexerUnavailable,
   OperationFailed as OperationFailed2
 } from "@openzeppelin/ui-builder-types";
-import { appConfigService as appConfigService2, logger as logger19 } from "@openzeppelin/ui-builder-utils";
+import {
+  appConfigService as appConfigService2,
+  isValidUrl,
+  logger as logger19,
+  userNetworkServiceConfigService
+} from "@openzeppelin/ui-builder-utils";
 var LOG_SYSTEM3 = "StellarIndexerClient";
+function getUserIndexerEndpoints(networkId) {
+  const svcCfg = userNetworkServiceConfigService.get(networkId, "indexer");
+  if (!svcCfg || typeof svcCfg !== "object") {
+    return void 0;
+  }
+  const endpoints = {};
+  if ("indexerUri" in svcCfg && svcCfg.indexerUri) {
+    const httpUrl = String(svcCfg.indexerUri).trim();
+    if (httpUrl && isValidUrl(httpUrl)) {
+      endpoints.http = httpUrl;
+    } else if (httpUrl) {
+      logger19.warn(
+        LOG_SYSTEM3,
+        `User-configured indexer HTTP URL for ${networkId} is invalid: ${httpUrl}. Ignoring.`
+      );
+    }
+  }
+  if ("indexerWsUri" in svcCfg && svcCfg.indexerWsUri) {
+    const wsUrl = String(svcCfg.indexerWsUri).trim();
+    if (wsUrl && isValidUrl(wsUrl)) {
+      endpoints.ws = wsUrl;
+    } else if (wsUrl) {
+      logger19.warn(
+        LOG_SYSTEM3,
+        `User-configured indexer WebSocket URL for ${networkId} is invalid: ${wsUrl}. Ignoring.`
+      );
+    }
+  }
+  if (!endpoints.http && !endpoints.ws) {
+    return void 0;
+  }
+  return endpoints;
+}
 var StellarIndexerClient = class {
   constructor(networkConfig) {
     __publicField(this, "networkConfig");
     __publicField(this, "resolvedEndpoints", null);
     __publicField(this, "availabilityChecked", false);
     __publicField(this, "isAvailable", false);
+    __publicField(this, "unsubscribeFromConfigChanges");
     this.networkConfig = networkConfig;
+    this.unsubscribeFromConfigChanges = userNetworkServiceConfigService.subscribe(
+      networkConfig.id,
+      "indexer",
+      () => {
+        logger19.info(
+          LOG_SYSTEM3,
+          `User indexer config changed for ${networkConfig.id}, resetting cache`
+        );
+        this.resetCache();
+      }
+    );
+  }
+  /**
+   * Resets the resolved endpoints and availability cache.
+   * Called when user configuration changes to force re-resolution.
+   */
+  resetCache() {
+    this.resolvedEndpoints = null;
+    this.availabilityChecked = false;
+    this.isAvailable = false;
+  }
+  /**
+   * Cleans up subscriptions when the client is no longer needed.
+   * Call this method when disposing of the client to prevent memory leaks.
+   */
+  dispose() {
+    this.unsubscribeFromConfigChanges();
   }
   /**
    * Check if indexer is available and configured
@@ -4033,10 +4099,11 @@ var StellarIndexerClient = class {
   /**
    * Resolve indexer endpoints with config precedence
    * Priority:
-   * 1. Runtime override from AppConfigService
-   * 2. Network config defaults (indexerUri/indexerWsUri)
-   * 3. Derived from RPC (if safe pattern exists)
-   * 4. None (returns empty object)
+   * 1. User-configured indexer from UserNetworkServiceConfigService (localStorage)
+   * 2. Runtime override from AppConfigService (environment/JSON config)
+   * 3. Network config defaults (indexerUri/indexerWsUri)
+   * 4. Derived from RPC (if safe pattern exists)
+   * 5. None (returns empty object)
    *
    * @returns Resolved indexer endpoints
    */
@@ -4046,6 +4113,23 @@ var StellarIndexerClient = class {
     }
     const networkId = this.networkConfig.id;
     const endpoints = {};
+    const userIndexerConfig = getUserIndexerEndpoints(networkId);
+    if (userIndexerConfig) {
+      if (userIndexerConfig.http) {
+        endpoints.http = userIndexerConfig.http;
+      }
+      if (userIndexerConfig.ws) {
+        endpoints.ws = userIndexerConfig.ws;
+      }
+      if (endpoints.http || endpoints.ws) {
+        logger19.info(
+          LOG_SYSTEM3,
+          `Using user-configured indexer for ${networkId}: http=${endpoints.http}, ws=${endpoints.ws}`
+        );
+        this.resolvedEndpoints = endpoints;
+        return endpoints;
+      }
+    }
     const indexerOverride = appConfigService2.getIndexerEndpointOverride(networkId);
     if (indexerOverride) {
       if (typeof indexerOverride === "string") {
@@ -4104,7 +4188,8 @@ var StellarIndexerClient = class {
       OWNERSHIP_TRANSFER_STARTED: "OWNERSHIP_TRANSFER_STARTED",
       OWNERSHIP_TRANSFER_COMPLETED: "OWNERSHIP_TRANSFER_COMPLETED",
       ADMIN_TRANSFER_INITIATED: "ADMIN_TRANSFER_INITIATED",
-      ADMIN_TRANSFER_COMPLETED: "ADMIN_TRANSFER_COMPLETED"
+      ADMIN_TRANSFER_COMPLETED: "ADMIN_TRANSFER_COMPLETED",
+      UNKNOWN: "UNKNOWN"
     };
     return mapping[changeType];
   }
@@ -5440,24 +5525,39 @@ var StellarAccessControlService = class {
       return [];
     }
   }
+  /**
+   * Disposes of the service and cleans up resources.
+   *
+   * Cleans up the indexer client's subscriptions to prevent memory leaks.
+   * Call this method when the service is no longer needed.
+   *
+   * Note: In typical usage where the service is application-scoped and lives
+   * for the duration of the application, calling dispose is not strictly necessary.
+   * However, it should be called if the service is created/destroyed dynamically
+   * (e.g., in tests or when switching networks).
+   */
+  dispose() {
+    this.indexerClient.dispose();
+    logger20.debug("StellarAccessControlService.dispose", "Service disposed");
+  }
 };
 function createStellarAccessControlService(networkConfig) {
   return new StellarAccessControlService(networkConfig);
 }
 
 // src/configuration/network-services.ts
-import { isValidUrl as isValidUrl2 } from "@openzeppelin/ui-builder-utils";
+import { isValidUrl as isValidUrl3 } from "@openzeppelin/ui-builder-utils";
 
 // src/configuration/rpc.ts
 import {
   appConfigService as appConfigService3,
-  isValidUrl,
+  isValidUrl as isValidUrl2,
   logger as logger21,
   userRpcConfigService as userRpcConfigService4
 } from "@openzeppelin/ui-builder-utils";
 function validateStellarRpcEndpoint(rpcConfig) {
   try {
-    if (!isValidUrl(rpcConfig.url)) {
+    if (!isValidUrl2(rpcConfig.url)) {
       logger21.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
       return false;
     }
@@ -5622,12 +5722,12 @@ async function validateStellarNetworkServiceConfig(serviceId, values) {
   }
   if (serviceId === "indexer") {
     if (values.indexerUri !== void 0 && values.indexerUri !== null && values.indexerUri !== "") {
-      if (!isValidUrl2(String(values.indexerUri))) {
+      if (!isValidUrl3(String(values.indexerUri))) {
         return false;
       }
     }
     if (values.indexerWsUri !== void 0 && values.indexerWsUri !== null && values.indexerWsUri !== "") {
-      if (!isValidUrl2(String(values.indexerWsUri))) {
+      if (!isValidUrl3(String(values.indexerWsUri))) {
         return false;
       }
     }
@@ -5648,7 +5748,7 @@ async function testStellarNetworkServiceConnection(serviceId, values) {
     if (!indexerUri || typeof indexerUri !== "string" || indexerUri.trim() === "") {
       return { success: true };
     }
-    if (!isValidUrl2(indexerUri)) {
+    if (!isValidUrl3(indexerUri)) {
       return { success: false, error: "Invalid indexer URI format" };
     }
     try {
@@ -8299,8 +8399,8 @@ var stellarTestnet = {
   sorobanRpcUrl: "https://soroban-testnet.stellar.org",
   networkPassphrase: "Test SDF Network ; September 2015",
   explorerUrl: "https://stellar.expert/explorer/testnet",
-  iconComponent: NetworkStellar2
-  // indexerUri and indexerWsUri will be added here when stable testnet indexer endpoints are available
+  iconComponent: NetworkStellar2,
+  indexerUri: "https://openzepplin-stellar-testnet.graphql.subquery.network"
 };
 
 // src/networks/index.ts