@openzeppelin/ui-builder-adapter-stellar 0.13.0 → 0.14.0

package/dist/index.js

@@ -6,9 +6,155 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 import { isStellarNetworkConfig } from "@openzeppelin/ui-builder-types";
 import { logger as logger35 } from "@openzeppelin/ui-builder-utils";
 
+// src/configuration/rpc.ts
+import {
+  appConfigService,
+  isValidUrl,
+  logger,
+  userRpcConfigService
+} from "@openzeppelin/ui-builder-utils";
+function validateStellarRpcEndpoint(rpcConfig) {
+  try {
+    if (!isValidUrl(rpcConfig.url)) {
+      logger.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    logger.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
+    return false;
+  }
+}
+async function testStellarRpcConnection(rpcConfig, timeoutMs = 5e3) {
+  if (!rpcConfig.url) {
+    return { success: false, error: "Soroban RPC URL is required" };
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const startTime = Date.now();
+    const response = await fetch(rpcConfig.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getHealth"
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP error: ${response.status}` };
+    }
+    const data = await response.json();
+    const latency = Date.now() - startTime;
+    if (data.error) {
+      return {
+        success: false,
+        error: `Soroban RPC error: ${data.error.message || "Unknown RPC error"}`
+      };
+    }
+    if (!data.result) {
+      return await testWithFallbackMethod(rpcConfig, controller.signal, startTime);
+    }
+    const healthStatus = data.result.status;
+    if (healthStatus && healthStatus !== "healthy") {
+      return {
+        success: false,
+        error: `Soroban RPC service unhealthy: ${healthStatus}`,
+        latency
+      };
+    }
+    return { success: true, latency };
+  } catch (error) {
+    logger.error("testStellarRpcConnection", "Connection test failed:", error);
+    if (error instanceof Error && error.name === "AbortError") {
+      return {
+        success: false,
+        error: `Connection timeout after ${timeoutMs}ms`
+      };
+    }
+    try {
+      return await testWithFallbackMethod(rpcConfig, controller.signal, Date.now());
+    } catch {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Connection failed"
+      };
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function testWithFallbackMethod(rpcConfig, signal, startTime) {
+  const response = await fetch(rpcConfig.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getLatestLedger"
+    }),
+    signal
+  });
+  if (!response.ok) {
+    return { success: false, error: `HTTP error: ${response.status}` };
+  }
+  const data = await response.json();
+  const latency = Date.now() - startTime;
+  if (data.error) {
+    return {
+      success: false,
+      error: `Soroban RPC error: ${data.error.message || "Unknown RPC error"}`
+    };
+  }
+  if (data.result && data.result.sequence) {
+    return { success: true, latency };
+  }
+  return {
+    success: false,
+    error: "Unexpected response format from Soroban RPC endpoint"
+  };
+}
+
+// src/configuration/network-services.ts
+function getStellarNetworkServiceForms() {
+  return [
+    {
+      id: "rpc",
+      label: "RPC Provider",
+      fields: [
+        {
+          id: "stellar-rpc-url",
+          name: "sorobanRpcUrl",
+          type: "text",
+          label: "Soroban RPC URL",
+          placeholder: "https://soroban.stellar.org",
+          validation: { required: true, pattern: "^https?://.+" },
+          width: "full"
+        }
+      ]
+    }
+  ];
+}
+async function validateStellarNetworkServiceConfig(serviceId, values) {
+  if (serviceId !== "rpc") return true;
+  const cfg = { url: String(values.sorobanRpcUrl || ""), isCustom: true };
+  return validateStellarRpcEndpoint(cfg);
+}
+async function testStellarNetworkServiceConnection(serviceId, values) {
+  if (serviceId !== "rpc") return { success: true };
+  const cfg = { url: String(values.sorobanRpcUrl || ""), isCustom: true };
+  return testStellarRpcConnection(cfg);
+}
+
 // src/contract/loader.ts
 import * as StellarSdk2 from "@stellar/stellar-sdk";
-import { logger as logger15 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger16 } from "@openzeppelin/ui-builder-utils";
 
 // src/validation/address.ts
 import { StrKey } from "@stellar/stellar-sdk";
@@ -91,7 +237,7 @@ function isValidAddress(address, addressType) {
 }
 
 // src/validation/eoa.ts
-import { logger } from "@openzeppelin/ui-builder-utils";
+import { logger as logger2 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG = "StellarEoaValidator";
 async function validateEoaConfig(config, walletStatus) {
   if (!config.allowAny) {
@@ -106,7 +252,7 @@ async function validateEoaConfig(config, walletStatus) {
         return `Connected wallet address (${walletStatus.address}) does not match the required specific Stellar address (${config.specificAddress}). Please connect the correct wallet.`;
       }
     } else if (walletStatus.isConnected && !walletStatus.address) {
-      logger.warn(
+      logger2.warn(
         SYSTEM_LOG_TAG,
         "Wallet is connected but address is unavailable for Stellar EOA validation."
       );
@@ -146,11 +292,11 @@ function getStellarExplorerTxUrl(txHash, networkConfig) {
 
 // src/mapping/struct-fields.ts
 import { xdr as xdr2 } from "@stellar/stellar-sdk";
-import { logger as logger3 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger4 } from "@openzeppelin/ui-builder-utils";
 
 // src/utils/type-detection.ts
 import * as StellarSdk from "@stellar/stellar-sdk";
-import { isDevelopmentOrTestEnvironment, logger as logger2 } from "@openzeppelin/ui-builder-utils";
+import { isDevelopmentOrTestEnvironment, logger as logger3 } from "@openzeppelin/ui-builder-utils";
 function extractSorobanTypeFromScSpec(scSpecType) {
   try {
     const typeSwitch = scSpecType.switch();
@@ -231,7 +377,7 @@ function extractSorobanTypeFromScSpec(scSpecType) {
         return udtType.name().toString();
       }
       default:
-        logger2.error("extractSorobanTypeFromScSpec", `\u{1F6A8} MISSING SCSPEC TYPE HANDLER \u{1F6A8}`, {
+        logger3.error("extractSorobanTypeFromScSpec", `\u{1F6A8} MISSING SCSPEC TYPE HANDLER \u{1F6A8}`, {
           typeSwitchValue: typeSwitch.value,
           typeSwitchName: typeSwitch.name,
           rawScSpecType: scSpecType,
@@ -250,11 +396,11 @@ function extractSorobanTypeFromScSpec(scSpecType) {
             `Missing ScSpec type handler: ${typeSwitch.name} (value: ${typeSwitch.value}). Please add support for this type.`
           );
         }
-        logger2.error("STELLAR_ADAPTER_MISSING_TYPE", "Missing ScSpec type handler:", errorReport);
+        logger3.error("STELLAR_ADAPTER_MISSING_TYPE", "Missing ScSpec type handler:", errorReport);
         return "unknown";
     }
   } catch (error) {
-    logger2.error("extractSorobanTypeFromScSpec", "Failed to extract type:", error);
+    logger3.error("extractSorobanTypeFromScSpec", "Failed to extract type:", error);
     return "unknown";
   }
 }
@@ -306,7 +452,7 @@ function extractStructFields(entries, structName) {
     }
     return null;
   } catch (error) {
-    logger3.error(
+    logger4.error(
       "extractStructFields",
       `Failed to extract struct fields for ${structName}:`,
       error
@@ -331,7 +477,7 @@ function isStructType(entries, typeName) {
     const isStruct = entryKind.value === xdr2.ScSpecEntryKind.scSpecEntryUdtStructV0().value;
     return isStruct;
   } catch (error) {
-    logger3.error("isStructType", `Failed to check if ${typeName} is struct:`, error);
+    logger4.error("isStructType", `Failed to check if ${typeName} is struct:`, error);
     return false;
   }
 }
@@ -347,15 +493,15 @@ import {
   rpc as StellarRpc,
   TransactionBuilder
 } from "@stellar/stellar-sdk";
-import { logger as logger10, userRpcConfigService } from "@openzeppelin/ui-builder-utils";
+import { logger as logger11, userRpcConfigService as userRpcConfigService2 } from "@openzeppelin/ui-builder-utils";
 
 // src/transform/parsers/index.ts
 import { isEnumValue as isEnumValue2 } from "@openzeppelin/ui-builder-types";
-import { isPlainObject as isPlainObject2, logger as logger8 } from "@openzeppelin/ui-builder-utils";
+import { isPlainObject as isPlainObject2, logger as logger9 } from "@openzeppelin/ui-builder-utils";
 
 // src/transform/parsers/generic-parser.ts
 import { isMapEntryArray } from "@openzeppelin/ui-builder-types";
-import { logger as logger4 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger5 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG2 = "GenericParser";
 function parseGenericType(typeString) {
   const match = typeString.match(/^(\w+)<(.*)>$/);
@@ -454,11 +600,11 @@ function parseGeneric(value, parameterType, parseInnerValue) {
         return value;
       }
       default:
-        logger4.warn(SYSTEM_LOG_TAG2, `Unknown generic type: ${baseType}`);
+        logger5.warn(SYSTEM_LOG_TAG2, `Unknown generic type: ${baseType}`);
         return null;
     }
   } catch (error) {
-    logger4.error(SYSTEM_LOG_TAG2, `Failed to parse generic type ${parameterType}:`, error);
+    logger5.error(SYSTEM_LOG_TAG2, `Failed to parse generic type ${parameterType}:`, error);
     throw error;
   }
 }
@@ -469,7 +615,7 @@ function isGenericType(parameterType) {
 
 // src/transform/parsers/primitive-parser.ts
 import { Address } from "@stellar/stellar-sdk";
-import { detectBytesEncoding, logger as logger5, stringToBytes } from "@openzeppelin/ui-builder-utils";
+import { detectBytesEncoding, logger as logger6, stringToBytes } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG3 = "PrimitiveParser";
 function parsePrimitive(value, parameterType) {
   try {
@@ -543,7 +689,7 @@ function parsePrimitive(value, parameterType) {
         return null;
     }
   } catch (error) {
-    logger5.error(SYSTEM_LOG_TAG3, `Failed to parse primitive ${parameterType}:`, error);
+    logger6.error(SYSTEM_LOG_TAG3, `Failed to parse primitive ${parameterType}:`, error);
     throw error;
   }
 }
@@ -739,7 +885,7 @@ function convertStellarTypeToScValType(stellarType) {
 
 // src/utils/input-parsing.ts
 import { nativeToScVal, xdr as xdr3 } from "@stellar/stellar-sdk";
-import { detectBytesEncoding as detectBytesEncoding2, logger as logger6, stringToBytes as stringToBytes2 } from "@openzeppelin/ui-builder-utils";
+import { detectBytesEncoding as detectBytesEncoding2, logger as logger7, stringToBytes as stringToBytes2 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG4 = "StellarInputParsingUtils";
 function isMapArray(argValue) {
   try {
@@ -770,7 +916,7 @@ function getScValFromPrimitive(v) {
     const typeHint = convertStellarTypeToScValType(v.type);
     return nativeToScVal(v.value, { type: typeHint });
   } catch (error) {
-    logger6.error(SYSTEM_LOG_TAG4, `Failed to convert primitive ${v.type}:`, error);
+    logger7.error(SYSTEM_LOG_TAG4, `Failed to convert primitive ${v.type}:`, error);
     throw new Error(`Failed to convert primitive value of type ${v.type}: ${error}`);
   }
 }
@@ -817,7 +963,7 @@ function convertEnumToScVal(obj, scVals) {
     const tupleVec = xdr3.ScVal.scvVec([tagSymbol, ...valuesVal]);
     return tupleVec;
   } catch (error) {
-    logger6.error(SYSTEM_LOG_TAG4, "Failed to convert enum:", error);
+    logger7.error(SYSTEM_LOG_TAG4, "Failed to convert enum:", error);
     throw new Error(`Failed to convert enum: ${error}`);
   }
 }
@@ -846,7 +992,7 @@ function convertObjectToMap(mapArray) {
     }, {});
     return { mapVal, mapType };
   } catch (error) {
-    logger6.error(SYSTEM_LOG_TAG4, "Failed to convert map:", error);
+    logger7.error(SYSTEM_LOG_TAG4, "Failed to convert map:", error);
     throw new Error(`Failed to convert map: ${error}`);
   }
 }
@@ -857,7 +1003,7 @@ import { isEnumValue } from "@openzeppelin/ui-builder-types";
 
 // src/transform/parsers/struct-parser.ts
 import { nativeToScVal as nativeToScVal3 } from "@stellar/stellar-sdk";
-import { isPlainObject, logger as logger7 } from "@openzeppelin/ui-builder-utils";
+import { isPlainObject, logger as logger8 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG5 = "StructParser";
 function needsParsing(value, fieldType) {
   if ((fieldType === "Bytes" || fieldType.startsWith("BytesN<")) && value instanceof Uint8Array) {
@@ -934,13 +1080,13 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
       );
     }
   }
-  logger7.debug(SYSTEM_LOG_TAG5, "convertStructToScVal final values:", {
+  logger8.debug(SYSTEM_LOG_TAG5, "convertStructToScVal final values:", {
     parameterType,
     convertedValue,
     typeHints
   });
   const scVal = nativeToScVal3(convertedValue, { type: typeHints });
-  logger7.debug(SYSTEM_LOG_TAG5, "convertStructToScVal generated ScVal:", {
+  logger8.debug(SYSTEM_LOG_TAG5, "convertStructToScVal generated ScVal:", {
     parameterType,
     scValType: scVal.switch().name,
     scValValue: scVal.value()
@@ -1102,14 +1248,14 @@ function parseStellarInput(value, parameterType) {
     }
     throw new Error(`Unsupported parameter type: ${parameterType} with value type ${typeof value}`);
   } catch (error) {
-    logger8.error(SYSTEM_LOG_TAG6, "Failed to parse Stellar input:", error);
+    logger9.error(SYSTEM_LOG_TAG6, "Failed to parse Stellar input:", error);
     throw error;
   }
 }
 
 // src/transform/output-formatter.ts
 import { scValToNative, xdr as xdr7 } from "@stellar/stellar-sdk";
-import { bytesToHex, logger as logger9 } from "@openzeppelin/ui-builder-utils";
+import { bytesToHex, logger as logger10 } from "@openzeppelin/ui-builder-utils";
 
 // src/types/artifacts.ts
 function isStellarContractArtifacts(obj) {
@@ -1132,7 +1278,7 @@ function validateAndConvertStellarArtifacts(source) {
 // src/transform/output-formatter.ts
 function formatStellarFunctionResult(result, functionDetails) {
   if (!functionDetails.outputs || !Array.isArray(functionDetails.outputs)) {
-    logger9.warn(
+    logger10.warn(
       "formatStellarFunctionResult",
       `Output definition missing or invalid for function ${functionDetails.name}.`
     );
@@ -1154,7 +1300,7 @@ function formatStellarFunctionResult(result, functionDetails) {
           valueToFormat = new Uint8Array(valueToFormat);
         }
       } catch (error) {
-        logger9.error("formatStellarFunctionResult", "Failed to convert ScVal to native", {
+        logger10.error("formatStellarFunctionResult", "Failed to convert ScVal to native", {
           functionName: functionDetails.name,
           error
         });
@@ -1195,7 +1341,7 @@ function formatStellarFunctionResult(result, functionDetails) {
     }
   } catch (error) {
     const errorMessage = `Error formatting result for ${functionDetails.name}: ${error.message}`;
-    logger9.error("formatStellarFunctionResult", errorMessage, {
+    logger10.error("formatStellarFunctionResult", errorMessage, {
       functionName: functionDetails.name,
       result,
       error
@@ -1227,12 +1373,12 @@ function getStellarWritableFunctions(contractSchema) {
 
 // src/query/handler.ts
 function getSorobanRpcServer(networkConfig) {
-  const customRpcConfig = userRpcConfigService.getUserRpcConfig(networkConfig.id);
+  const customRpcConfig = userRpcConfigService2.getUserRpcConfig(networkConfig.id);
   const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
   if (!rpcUrl) {
     throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
   }
-  logger10.info(
+  logger11.info(
     "getSorobanRpcServer",
     `Creating Soroban RPC server for ${networkConfig.name} using RPC: ${rpcUrl}`
   );
@@ -1263,12 +1409,12 @@ async function createSimulationTransaction(contractAddress, functionName, args,
     }).addOperation(contract2.call(functionName, ...scValArgs)).setTimeout(30);
     return transaction;
   } catch (error) {
-    logger10.error("createSimulationTransaction", "Failed to create simulation transaction:", error);
+    logger11.error("createSimulationTransaction", "Failed to create simulation transaction:", error);
     throw new Error(`Failed to create simulation transaction: ${error.message}`);
   }
 }
 async function checkStellarFunctionStateMutability(contractAddress, functionName, networkConfig, inputTypes = []) {
-  logger10.info(
+  logger11.info(
     "checkStellarFunctionStateMutability",
     `Checking state mutability for function: ${functionName} on ${contractAddress}`
   );
@@ -1310,7 +1456,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       networkConfig
     );
     const transaction = transactionBuilder.build();
-    logger10.debug(
+    logger11.debug(
       "checkStellarFunctionStateMutability",
       `[Check ${functionName}] Simulating transaction for state mutability check`
     );
@@ -1318,7 +1464,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
     try {
       simulationResult = await rpcServer.simulateTransaction(transaction);
     } catch (simulationError) {
-      logger10.warn(
+      logger11.warn(
         "checkStellarFunctionStateMutability",
         `[Check ${functionName}] Simulation failed, assuming function modifies state:`,
         simulationError
@@ -1326,7 +1472,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       return true;
     }
     if (StellarRpc.Api.isSimulationError(simulationResult)) {
-      logger10.warn(
+      logger11.warn(
         "checkStellarFunctionStateMutability",
         `[Check ${functionName}] Simulation error, assuming function modifies state:`,
         simulationResult.error
@@ -1334,7 +1480,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       return true;
     }
     const hasStateChanges = simulationResult.stateChanges && simulationResult.stateChanges.length > 0;
-    logger10.info(
+    logger11.info(
       "checkStellarFunctionStateMutability",
       `[Check ${functionName}] State mutability check complete:`,
       {
@@ -1345,7 +1491,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
     );
     return Boolean(hasStateChanges);
   } catch (error) {
-    logger10.warn(
+    logger11.warn(
       "checkStellarFunctionStateMutability",
       `Failed to check state mutability for ${functionName}, assuming it modifies state:`,
       error
@@ -1354,7 +1500,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
   }
 }
 async function queryStellarViewFunction(contractAddress, functionId, networkConfig, params = [], contractSchema, loadContractFn) {
-  logger10.info(
+  logger11.info(
     "queryStellarViewFunction",
     `Querying Stellar view function: ${functionId} on ${contractAddress} (${networkConfig.name})`,
     { params }
@@ -1396,7 +1542,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       const rawValue = params[index];
       return parseStellarInput(rawValue, inputParam.type);
     });
-    logger10.debug("queryStellarViewFunction", "Parsed Args for contract call:", args);
+    logger11.debug("queryStellarViewFunction", "Parsed Args for contract call:", args);
     const paramTypes = expectedInputs.map((input) => input.type);
     const transactionBuilder = await createSimulationTransaction(
       contractAddress,
@@ -1406,7 +1552,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       stellarConfig
     );
     const transaction = transactionBuilder.build();
-    logger10.debug(
+    logger11.debug(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Simulating transaction:`,
       transaction.toXDR()
@@ -1415,7 +1561,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
     try {
       simulationResult = await rpcServer.simulateTransaction(transaction);
     } catch (simulationError) {
-      logger10.error(
+      logger11.error(
         "queryStellarViewFunction",
         `[Query ${functionDetails.name}] Simulation failed:`,
         simulationError
@@ -1425,7 +1571,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       );
     }
     if (StellarRpc.Api.isSimulationError(simulationResult)) {
-      logger10.error(
+      logger11.error(
         "queryStellarViewFunction",
         `[Query ${functionDetails.name}] Simulation error:`,
         simulationResult.error
@@ -1436,13 +1582,13 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       throw new Error(`No result returned from contract simulation for ${functionDetails.name}`);
     }
     const rawResult = simulationResult.result.retval;
-    logger10.debug(
+    logger11.debug(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Raw simulation result:`,
       rawResult
     );
     const formattedResult = formatStellarFunctionResult(rawResult, functionDetails);
-    logger10.info(
+    logger11.info(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Formatted result:`,
       formattedResult
@@ -1450,7 +1596,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
     return formattedResult;
   } catch (error) {
     const errorMessage = `Failed to query Stellar view function ${functionId} on network ${networkConfig.name}: ${error.message}`;
-    logger10.error("queryStellarViewFunction", errorMessage, {
+    logger11.error("queryStellarViewFunction", errorMessage, {
       contractAddress,
       functionId,
       params,
@@ -1462,10 +1608,10 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
 }
 
 // src/sac/spec-cache.ts
-import { logger as logger13 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger14 } from "@openzeppelin/ui-builder-utils";
 
 // src/sac/spec-source.ts
-import { logger as logger11 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger12 } from "@openzeppelin/ui-builder-utils";
 var DEFAULT_SPEC = {
   repo: "stellar/stellar-asset-contract-spec",
   path: "refs/heads/main",
@@ -1486,7 +1632,7 @@ async function fetchSacSpecJson(cfg = {}) {
     }
     return await res.text();
   } catch (error) {
-    logger11.error("stellar:sac:spec-source", "Failed to fetch SAC spec:", url, error);
+    logger12.error("stellar:sac:spec-source", "Failed to fetch SAC spec:", url, error);
     throw new Error("Failed to load Stellar Asset Contract spec. Please try again later.");
   }
 }
@@ -1495,7 +1641,7 @@ async function fetchSacSpecJson(cfg = {}) {
 import { xdr as xdr8 } from "@stellar/stellar-sdk";
 import { parse, stringify } from "lossless-json";
 import stellarXdrJsonPackage from "@stellar/stellar-xdr-json/package.json";
-import { logger as logger12 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger13 } from "@openzeppelin/ui-builder-utils";
 var stellarXdrJsonVersion = stellarXdrJsonPackage.version ?? "23.0.0";
 var CDN_WASM_URL = `https://unpkg.com/@stellar/stellar-xdr-json@${stellarXdrJsonVersion}/stellar_xdr_json_bg.wasm`;
 var initialized = false;
@@ -1509,7 +1655,7 @@ async function ensureXdrJsonInitialized() {
     encode = stellarXdrJson.encode;
     initialized = true;
   } catch (error) {
-    logger12.error("stellar:sac:xdr", "Failed to initialize WASM module:", error);
+    logger13.error("stellar:sac:xdr", "Failed to initialize WASM module:", error);
     throw error;
   }
 }
@@ -1531,7 +1677,7 @@ async function encodeSacSpecEntries(jsonString) {
     }
     return result;
   } catch (error) {
-    logger12.error("stellar:sac:xdr", "Failed to encode SAC spec to XDR", error);
+    logger13.error("stellar:sac:xdr", "Failed to encode SAC spec to XDR", error);
     throw new Error("Failed to process SAC spec.");
   }
 }
@@ -1546,7 +1692,7 @@ async function getSacSpecArtifacts(cfg = {}) {
   const cacheKey = getSacSpecUrl(cfg);
   const cached = sacSpecCache.get(cacheKey);
   if (cached) {
-    logger13.debug("stellar:sac:spec-cache", "Returning cached SAC spec artifacts");
+    logger14.debug("stellar:sac:spec-cache", "Returning cached SAC spec artifacts");
     return cached;
   }
   const inflight = sacSpecInflight.get(cacheKey);
@@ -1563,7 +1709,7 @@ async function getSacSpecArtifacts(cfg = {}) {
     };
     sacSpecCache.set(cacheKey, entry);
     sacSpecInflight.delete(cacheKey);
-    logger13.debug("stellar:sac:spec-cache", "Cached SAC spec artifacts for future re-use");
+    logger14.debug("stellar:sac:spec-cache", "Cached SAC spec artifacts for future re-use");
     return entry;
   })().catch((error) => {
     sacSpecInflight.delete(cacheKey);
@@ -1575,9 +1721,9 @@ async function getSacSpecArtifacts(cfg = {}) {
 
 // src/contract/type.ts
 import { Contract as Contract2, rpc as StellarRpc2, xdr as xdr9 } from "@stellar/stellar-sdk";
-import { logger as logger14, userRpcConfigService as userRpcConfigService2 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger15, userRpcConfigService as userRpcConfigService3 } from "@openzeppelin/ui-builder-utils";
 function getSorobanRpcServer2(networkConfig) {
-  const customRpcConfig = userRpcConfigService2.getUserRpcConfig(networkConfig.id);
+  const customRpcConfig = userRpcConfigService3.getUserRpcConfig(networkConfig.id);
   const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
   if (!rpcUrl) {
     throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
@@ -1608,7 +1754,7 @@ async function getStellarContractType(contractId, networkConfig) {
     if (detected === execStellarAssetType) return "contractExecutableStellarAsset";
     return null;
   } catch (error) {
-    logger14.error("stellar:contract-type", "Failed to detect contract type:", error);
+    logger15.error("stellar:contract-type", "Failed to detect contract type:", error);
     throw new Error(
       `Something went wrong getting contract type by contract ID. ${error.message}`
     );
@@ -1617,7 +1763,7 @@ async function getStellarContractType(contractId, networkConfig) {
 
 // src/contract/loader.ts
 async function loadStellarContractFromAddress(contractAddress, networkConfig) {
-  logger15.info("loadStellarContractFromAddress", "Loading contract:", {
+  logger16.info("loadStellarContractFromAddress", "Loading contract:", {
     contractAddress,
     network: networkConfig.name,
     rpcUrl: networkConfig.sorobanRpcUrl,
@@ -1648,7 +1794,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
         };
       }
     } catch (e) {
-      logger15.warn(
+      logger16.warn(
         "loadStellarContractFromAddress",
         "SAC detection failed, falling back to regular client:",
         e
@@ -1665,12 +1811,12 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
       const message = e?.message || String(e);
       if (message.includes("Cannot destructure property 'length'")) {
         const friendly = "Unable to fetch contract metadata from RPC. The contract appears to have no published Wasm/definition on this network.";
-        logger15.error("loadStellarContractFromAddress", friendly);
+        logger16.error("loadStellarContractFromAddress", friendly);
         throw new Error(`NO_WASM: ${friendly}`);
       }
       throw e;
     }
-    logger15.info("loadStellarContractFromAddress", "Contract client created successfully");
+    logger16.info("loadStellarContractFromAddress", "Contract client created successfully");
     let specEntries = [];
     try {
       if (contractClient.spec && typeof contractClient.spec === "object") {
@@ -1685,20 +1831,20 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            logger15.warn("loadStellarContractFromAddress", "entries() method failed:", e);
+            logger16.warn("loadStellarContractFromAddress", "entries() method failed:", e);
           }
         }
         if (specEntries.length === 0 && typeof spec.entries === "function") {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            logger15.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
+            logger16.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
           }
         }
-        logger15.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
+        logger16.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
       }
     } catch (specError) {
-      logger15.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
+      logger16.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
     }
     const functions = await extractFunctionsFromSpec(
       contractClient.spec,
@@ -1706,7 +1852,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
       specEntries,
       networkConfig
     );
-    logger15.info(
+    logger16.info(
       "loadStellarContractFromAddress",
       `Successfully extracted ${functions.length} functions`
     );
@@ -1721,28 +1867,28 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
   } catch (error) {
     const msg = error?.message || String(error);
     if (msg.startsWith("NO_WASM:")) {
-      logger15.error("loadStellarContractFromAddress", msg);
+      logger16.error("loadStellarContractFromAddress", msg);
       throw new Error(msg);
     }
-    logger15.error("loadStellarContractFromAddress", "Failed to load contract:", error);
+    logger16.error("loadStellarContractFromAddress", "Failed to load contract:", error);
     throw new Error(`Failed to load contract: ${msg}`);
   }
 }
 async function extractFunctionsFromSpec(spec, contractAddress, specEntries, networkConfig) {
   try {
     const specFunctions = spec.funcs();
-    logger15.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
+    logger16.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
     return await Promise.all(
       specFunctions.map(async (func, index) => {
         try {
           const functionName = func.name().toString();
-          logger15.info("extractFunctionsFromSpec", `Processing function: ${functionName}`);
+          logger16.info("extractFunctionsFromSpec", `Processing function: ${functionName}`);
           const inputs = func.inputs().map((input, inputIndex) => {
             try {
               const inputName = input.name().toString();
               const inputType = extractSorobanTypeFromScSpec(input.type());
               if (inputType === "unknown") {
-                logger15.warn(
+                logger16.warn(
                   "extractFunctionsFromSpec",
                   `Unknown type for parameter "${inputName}" in function "${functionName}"`
                 );
@@ -1752,12 +1898,12 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 const structFields = extractStructFields(specEntries, inputType);
                 if (structFields && structFields.length > 0) {
                   components = structFields;
-                  logger15.debug(
+                  logger16.debug(
                     "extractFunctionsFromSpec",
                     `Extracted ${structFields.length} fields for struct type "${inputType}": ${structFields.map((f) => `${f.name}:${f.type}`).join(", ")}`
                   );
                 } else {
-                  logger15.warn(
+                  logger16.warn(
                     "extractFunctionsFromSpec",
                     `No fields extracted for struct "${inputType}"`
                   );
@@ -1769,7 +1915,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 ...components && { components }
               };
             } catch (error) {
-              logger15.warn(
+              logger16.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse input ${inputIndex}:`,
                 error
@@ -1788,7 +1934,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 type: outputType
               };
             } catch (error) {
-              logger15.warn(
+              logger16.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse output ${outputIndex}:`,
                 error
@@ -1804,7 +1950,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
           if (networkConfig) {
             try {
               const inputTypes = inputs.map((input) => input.type);
-              logger15.debug(
+              logger16.debug(
                 "extractFunctionsFromSpec",
                 `Checking state mutability for ${functionName} with input types: ${inputTypes.join(", ")}`
               );
@@ -1815,20 +1961,20 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 inputTypes
               );
               stateMutability = modifiesState ? "nonpayable" : "view";
-              logger15.info(
+              logger16.info(
                 "extractFunctionsFromSpec",
                 `Function ${functionName} state mutability determined:`,
                 { modifiesState, stateMutability }
               );
             } catch (error) {
-              logger15.warn(
+              logger16.warn(
                 "extractFunctionsFromSpec",
                 `Failed to determine state mutability for ${functionName}, assuming it modifies state:`,
                 error
               );
             }
           } else {
-            logger15.warn(
+            logger16.warn(
               "extractFunctionsFromSpec",
               `No network config provided for ${functionName}, assuming it modifies state`
             );
@@ -1846,7 +1992,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
             stateMutability
           };
         } catch (error) {
-          logger15.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
+          logger16.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
           return {
             id: `function_${index}`,
             name: `function_${index}`,
@@ -1862,7 +2008,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
       })
     );
   } catch (error) {
-    logger15.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
+    logger16.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
     throw new Error(`Failed to extract functions: ${error.message}`);
   }
 }
@@ -2170,13 +2316,13 @@ import {
   Configuration,
   RelayersApi
 } from "@openzeppelin/relayer-sdk";
-import { logger as logger21 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger22 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/connection.ts
-import { logger as logger20 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger21 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/utils/stellarWalletImplementationManager.ts
-import { appConfigService, logger as logger17 } from "@openzeppelin/ui-builder-utils";
+import { appConfigService as appConfigService2, logger as logger18 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/implementation/wallets-kit-implementation.ts
 import {
@@ -2184,7 +2330,7 @@ import {
   StellarWalletsKit,
   WalletNetwork
 } from "@creit.tech/stellar-wallets-kit";
-import { logger as logger16 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger17 } from "@openzeppelin/ui-builder-utils";
 var LOG_SYSTEM = "StellarWalletImplementation";
 var WalletsKitImplementation = class {
   /**
@@ -2205,7 +2351,7 @@ var WalletsKitImplementation = class {
     __publicField(this, "currentWalletId", null);
     __publicField(this, "connectionStatusListeners", /* @__PURE__ */ new Set());
     this.networkConfig = networkConfig || null;
-    logger16.info(
+    logger17.info(
       LOG_SYSTEM,
       "Constructor called. Initial anticipated kitName:",
       initialUiKitConfig?.kitName,
@@ -2213,7 +2359,7 @@ var WalletsKitImplementation = class {
       networkConfig?.name
     );
     this.initialized = true;
-    logger16.info(
+    logger17.info(
       LOG_SYSTEM,
       "StellarWalletImplementation instance initialized (StellarWalletsKit config creation deferred)."
     );
@@ -2223,10 +2369,10 @@ var WalletsKitImplementation = class {
    * @param config - The Stellar network configuration
    */
   setNetworkConfig(config) {
-    logger16.info(LOG_SYSTEM, "Network config updated:", config.name);
+    logger17.info(LOG_SYSTEM, "Network config updated:", config.name);
     this.networkConfig = config;
     if (this.activeStellarKit || this.defaultInstanceKit) {
-      logger16.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
+      logger17.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
     }
   }
   /**
@@ -2236,14 +2382,14 @@ var WalletsKitImplementation = class {
    * @param kit - The StellarWalletsKit object to set as active, or null to clear it.
    */
   setActiveStellarKit(kit) {
-    logger16.info(
+    logger17.info(
       LOG_SYSTEM,
       "setActiveStellarKit called with kit:",
       kit ? "Valid StellarWalletsKit" : "Null"
     );
     this.activeStellarKit = kit;
     if (this.unsubscribeFromStatusChanges) {
-      logger16.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
+      logger17.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
     }
   }
   /**
@@ -2252,14 +2398,14 @@ var WalletsKitImplementation = class {
    * @returns A default StellarWalletsKit instance
    */
   createDefaultKit() {
-    logger16.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
+    logger17.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
     const network = this.getWalletNetwork();
     const kit = new StellarWalletsKit({
       network,
       selectedWalletId: void 0,
       modules: allowAllModules()
     });
-    logger16.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
+    logger17.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
     return kit;
   }
   /**
@@ -2267,7 +2413,7 @@ var WalletsKitImplementation = class {
    */
   getWalletNetwork() {
     if (!this.networkConfig) {
-      logger16.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
+      logger17.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
       return WalletNetwork.TESTNET;
     }
     return this.networkConfig.type === "mainnet" ? WalletNetwork.PUBLIC : WalletNetwork.TESTNET;
@@ -2285,7 +2431,7 @@ var WalletsKitImplementation = class {
    */
   async getAvailableConnectors() {
     if (!this.initialized) {
-      logger16.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
+      logger17.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
       return [];
     }
     try {
@@ -2298,10 +2444,10 @@ var WalletsKitImplementation = class {
         installed: wallet.isAvailable,
         type: wallet.type || "browser"
       }));
-      logger16.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
+      logger17.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
       return connectors;
     } catch (error) {
-      logger16.error(LOG_SYSTEM, "Failed to get available connectors:", error);
+      logger17.error(LOG_SYSTEM, "Failed to get available connectors:", error);
       return [];
     }
   }
@@ -2317,7 +2463,7 @@ var WalletsKitImplementation = class {
     try {
       const prevStatus = this.getWalletConnectionStatus();
       const kit = this.getKitToUse();
-      logger16.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
+      logger17.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
       kit.setWallet(connectorId);
       const result = await kit.getAddress();
       if (result.address) {
@@ -2325,7 +2471,7 @@ var WalletsKitImplementation = class {
         this.currentWalletId = connectorId;
         const newStatus = this.getWalletConnectionStatus();
         this.notifyConnectionListeners(newStatus, prevStatus);
-        logger16.info(
+        logger17.info(
           LOG_SYSTEM,
           `Successfully connected to wallet: ${connectorId}, address: ${result.address}`
         );
@@ -2341,7 +2487,7 @@ var WalletsKitImplementation = class {
         };
       }
     } catch (error) {
-      logger16.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
+      logger17.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
       return {
         connected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2358,15 +2504,15 @@ var WalletsKitImplementation = class {
     }
     try {
       const prevStatus = this.getWalletConnectionStatus();
-      logger16.info(LOG_SYSTEM, "Disconnecting wallet");
+      logger17.info(LOG_SYSTEM, "Disconnecting wallet");
       this.currentAddress = null;
       this.currentWalletId = null;
       const newStatus = this.getWalletConnectionStatus();
       this.notifyConnectionListeners(newStatus, prevStatus);
-      logger16.info(LOG_SYSTEM, "Successfully disconnected wallet");
+      logger17.info(LOG_SYSTEM, "Successfully disconnected wallet");
       return { disconnected: true };
     } catch (error) {
-      logger16.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
+      logger17.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
       return {
         disconnected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2399,15 +2545,15 @@ var WalletsKitImplementation = class {
    */
   onWalletConnectionChange(callback) {
     if (!this.initialized) {
-      logger16.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
+      logger17.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
       return () => {
       };
     }
     this.connectionStatusListeners.add(callback);
-    logger16.info(LOG_SYSTEM, "Connection status listener added");
+    logger17.info(LOG_SYSTEM, "Connection status listener added");
     return () => {
       this.connectionStatusListeners.delete(callback);
-      logger16.debug(LOG_SYSTEM, "Connection status listener removed");
+      logger17.debug(LOG_SYSTEM, "Connection status listener removed");
     };
   }
   /**
@@ -2442,7 +2588,7 @@ var WalletsKitImplementation = class {
     }
     const kit = this.getKitToUse();
     const networkPassphrase = this.getWalletNetwork();
-    logger16.info(LOG_SYSTEM, "Signing transaction with wallet");
+    logger17.info(LOG_SYSTEM, "Signing transaction with wallet");
     return await kit.signTransaction(xdr13, {
       address,
       networkPassphrase
@@ -2456,7 +2602,7 @@ var WalletsKitImplementation = class {
       try {
         listener(currentStatus, previousStatus);
       } catch (error) {
-        logger16.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
+        logger17.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
       }
     });
   }
@@ -2469,7 +2615,7 @@ var WalletsKitImplementation = class {
       this.unsubscribeFromStatusChanges = void 0;
     }
     this.connectionStatusListeners.clear();
-    logger16.info(LOG_SYSTEM, "Cleanup completed");
+    logger17.info(LOG_SYSTEM, "Cleanup completed");
   }
 };
 
@@ -2493,17 +2639,17 @@ async function getStellarWalletImplementation(networkConfig) {
   }
   walletImplementationPromise = (async () => {
     try {
-      logger17.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
-      const initialUiKitConfig = appConfigService.getTypedNestedConfig(
+      logger18.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
+      const initialUiKitConfig = appConfigService2.getTypedNestedConfig(
         "walletui",
         "config"
       );
       const instance = new WalletsKitImplementation(networkConfig, initialUiKitConfig);
-      logger17.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
+      logger18.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
       walletImplementationInstance = instance;
       return instance;
     } catch (error) {
-      logger17.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
+      logger18.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
       const fallbackInstance = new WalletsKitImplementation(networkConfig);
       walletImplementationInstance = fallbackInstance;
       return fallbackInstance;
@@ -2513,7 +2659,7 @@ async function getStellarWalletImplementation(networkConfig) {
 }
 function getInitializedStellarWalletImplementation() {
   if (!walletImplementationInstance) {
-    logger17.warn(
+    logger18.warn(
       LOG_SYSTEM2,
       "getInitializedStellarWalletImplementation called before instance was ready."
     );
@@ -2523,7 +2669,7 @@ function getInitializedStellarWalletImplementation() {
 
 // src/wallet/stellar-wallets-kit/stellarUiKitManager.ts
 import { allowAllModules as allowAllModules2, StellarWalletsKit as StellarWalletsKit2, WalletNetwork as WalletNetwork2 } from "@creit.tech/stellar-wallets-kit";
-import { logger as logger18 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger19 } from "@openzeppelin/ui-builder-utils";
 var getInitialState = () => ({
   isConfigured: false,
   isInitializing: false,
@@ -2560,13 +2706,13 @@ function setNetworkConfig(config) {
 }
 function getWalletNetwork(networkConfig) {
   if (!networkConfig) {
-    logger18.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
+    logger19.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
     return WalletNetwork2.TESTNET;
   }
   return networkConfig.type === "mainnet" ? WalletNetwork2.PUBLIC : WalletNetwork2.TESTNET;
 }
 async function configure(newFullUiKitConfig) {
-  logger18.info(
+  logger19.info(
     "StellarUiKitManager:configure",
     "Configuring UI kit. New config:",
     newFullUiKitConfig
@@ -2596,7 +2742,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      logger18.info(
+      if (state.networkConfig) {
+        try {
+          const impl = await getStellarWalletImplementation(state.networkConfig);
+          impl.setActiveStellarKit(kit);
+          logger19.debug(
+            "StellarUiKitManager:configure",
+            "Active kit wired into wallet implementation for stellar-wallets-kit"
+          );
+        } catch (error) {
+          logger19.warn(
+            "StellarUiKitManager:configure",
+            "Failed to attach active kit to wallet implementation:",
+            error
+          );
+        }
+      }
+      logger19.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured with built-in UI and all wallet modules"
       );
@@ -2610,7 +2772,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      logger18.info(
+      if (state.networkConfig) {
+        try {
+          const impl = await getStellarWalletImplementation(state.networkConfig);
+          impl.setActiveStellarKit(kit);
+          logger19.debug(
+            "StellarUiKitManager:configure",
+            "Active kit wired into wallet implementation for custom"
+          );
+        } catch (error) {
+          logger19.warn(
+            "StellarUiKitManager:configure",
+            "Failed to attach active kit to wallet implementation:",
+            error
+          );
+        }
+      }
+      logger19.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured for custom UI components"
       );
@@ -2619,7 +2797,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = false;
       state.error = null;
-      logger18.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
+      if (state.networkConfig) {
+        try {
+          const impl = await getStellarWalletImplementation(state.networkConfig);
+          impl.setActiveStellarKit(null);
+          logger19.debug(
+            "StellarUiKitManager:configure",
+            "Active kit cleared from wallet implementation for none"
+          );
+        } catch (error) {
+          logger19.warn(
+            "StellarUiKitManager:configure",
+            "Failed to clear active kit from wallet implementation:",
+            error
+          );
+        }
+      }
+      logger19.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
     } else {
       throw new Error(`Unknown UI kit name: ${newKitName}`);
     }
@@ -2632,7 +2826,7 @@ async function configure(newFullUiKitConfig) {
     };
     notifyListeners();
   } catch (error) {
-    logger18.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
+    logger19.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
     state = {
       ...state,
       isInitializing: false,
@@ -2666,9 +2860,7 @@ function generateStellarWalletsKitConfigFile(userConfig) {
 import { 
   StellarWalletsKit, 
   WalletNetwork, 
-  allowAllModules,
-  WalletConnectModule,
-  WalletConnectAllowedMethods
+  allowAllModules
 } from '@creit.tech/stellar-wallets-kit';
 
 /**
@@ -2703,18 +2895,7 @@ export const stellarWalletsKitConfig = {
  */
 export function createStellarWalletsKit(): StellarWalletsKit {
   const modules = [
-    ...allowAllModules(),
-    ${walletConnectProjectId ? `
-    // WalletConnect module with custom configuration
-    new WalletConnectModule({
-      url: window.location.origin,
-      projectId: stellarWalletsKitConfig.walletConnectProjectId,
-      method: WalletConnectAllowedMethods.SIGN,
-      description: stellarWalletsKitConfig.appName,
-      name: stellarWalletsKitConfig.appName,
-      icons: [],
-      network: stellarWalletsKitConfig.network,
-    }),` : ""}
+    ...allowAllModules()
   ];
 
   return new StellarWalletsKit({
@@ -2736,7 +2917,7 @@ function generateStellarWalletsKitExportables(uiKitConfig) {
 
 // src/wallet/stellar-wallets-kit/StellarWalletsKitConnectButton.tsx
 import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { logger as logger19 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger20 } from "@openzeppelin/ui-builder-utils";
 import { jsx as jsx5 } from "react/jsx-runtime";
 function StellarWalletsKitConnectButton() {
   const containerRef = useRef2(null);
@@ -2744,7 +2925,7 @@ function StellarWalletsKitConnectButton() {
     const state2 = stellarUiKitManager.getState();
     const kit = state2.stellarKitProvider;
     if (!kit || !containerRef.current) {
-      logger19.error(
+      logger20.error(
         "StellarWalletsKitConnectButton",
         "Kit not initialized or container not available"
       );
@@ -2753,10 +2934,28 @@ function StellarWalletsKitConnectButton() {
     kit.createButton({
       container: containerRef.current,
       onConnect: ({ address }) => {
-        logger19.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        logger20.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        try {
+          setStellarConnectedAddress(address ?? null);
+        } catch (error) {
+          logger20.warn(
+            "StellarWalletsKitConnectButton",
+            "Failed to set connected address in adapter implementation:",
+            error
+          );
+        }
       },
       onDisconnect: () => {
-        logger19.info("StellarWalletsKitConnectButton", "Disconnected");
+        logger20.info("StellarWalletsKitConnectButton", "Disconnected");
+        try {
+          setStellarConnectedAddress(null);
+        } catch (error) {
+          logger20.warn(
+            "StellarWalletsKitConnectButton",
+            "Failed to clear connected address in adapter implementation:",
+            error
+          );
+        }
       },
       buttonText: "Connect Wallet"
     });
@@ -2765,10 +2964,10 @@ function StellarWalletsKitConnectButton() {
         try {
           kit.removeButton();
         } catch (error) {
-          logger19.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
+          logger20.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
         }
       } else {
-        logger19.warn(
+        logger20.warn(
           "StellarWalletsKitConnectButton",
           "removeButton method not available on kit instance"
         );
@@ -2797,7 +2996,7 @@ async function disconnectStellarWallet() {
 function getStellarWalletConnectionStatus() {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    logger20.warn(
+    logger21.warn(
       "getStellarWalletConnectionStatus",
       "Wallet implementation not ready. Returning default disconnected state."
     );
@@ -2816,10 +3015,21 @@ function getStellarWalletConnectionStatus() {
     walletId: status.walletId
   };
 }
+function setStellarConnectedAddress(address, walletId) {
+  const impl = getInitializedStellarWalletImplementation();
+  if (impl) {
+    impl.updateConnectionStatus(address, walletId);
+  } else {
+    logger21.warn(
+      "setStellarConnectedAddress",
+      "Wallet implementation not ready. Cannot update connection status."
+    );
+  }
+}
 function onStellarWalletConnectionChange(callback) {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    logger20.warn(
+    logger21.warn(
       "onStellarWalletConnectionChange",
       "Wallet implementation not ready. Returning no-op."
     );
@@ -2842,7 +3052,7 @@ function onStellarWalletConnectionChange(callback) {
     try {
       callback(currentStatus, previousStatus);
     } catch (error) {
-      logger20.error("Error in Stellar connection status listener:", String(error));
+      logger21.error("Error in Stellar connection status listener:", String(error));
     }
   });
 }
@@ -2887,7 +3097,7 @@ var RelayerExecutionStrategy = class {
    * @throws If the API call fails or returns an unsuccessful response.
    */
   async getStellarRelayers(serviceUrl, accessToken, networkConfig) {
-    logger21.info(
+    logger22.info(
       "[StellarRelayer] Getting relayers with access token",
       accessToken.slice(0, 5).padEnd(accessToken.length, "*")
     );
@@ -2935,7 +3145,7 @@ var RelayerExecutionStrategy = class {
    * @throws If any API call fails or returns an unsuccessful response.
    */
   async getStellarRelayer(serviceUrl, accessToken, relayerId, _networkConfig) {
-    logger21.info("[StellarRelayer] Getting detailed relayer info", relayerId);
+    logger22.info("[StellarRelayer] Getting detailed relayer info", relayerId);
     const sdkConfig = new Configuration({
       basePath: serviceUrl,
       accessToken
@@ -2945,11 +3155,11 @@ var RelayerExecutionStrategy = class {
       const [relayerResponse, balanceResponse, statusResponse] = await Promise.all([
         relayersApi.getRelayer(relayerId),
         relayersApi.getRelayerBalance(relayerId).catch((err) => {
-          logger21.warn("[StellarRelayer] Failed to fetch balance", err);
+          logger22.warn("[StellarRelayer] Failed to fetch balance", err);
           return null;
         }),
         relayersApi.getRelayerStatus(relayerId).catch((err) => {
-          logger21.warn("[StellarRelayer] Failed to fetch status", err);
+          logger22.warn("[StellarRelayer] Failed to fetch status", err);
           return null;
         })
       ]);
@@ -2971,7 +3181,7 @@ var RelayerExecutionStrategy = class {
           const balanceInXlm = balanceInStroops / 1e7;
           enhancedDetails.balance = `${balanceInXlm.toFixed(7)} XLM`;
         } catch (error) {
-          logger21.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
+          logger22.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
           enhancedDetails.balance = String(balanceResponse.data.data.balance);
         }
       }
@@ -2990,13 +3200,13 @@ var RelayerExecutionStrategy = class {
           }
         }
       }
-      logger21.info(
+      logger22.info(
         "[StellarRelayer] Retrieved enhanced relayer details",
         JSON.stringify(enhancedDetails)
       );
       return enhancedDetails;
     } catch (error) {
-      logger21.error(
+      logger22.error(
         "[StellarRelayer] Failed to get relayer details",
         error instanceof Error ? error.message : String(error)
       );
@@ -3252,10 +3462,10 @@ var RelayerExecutionStrategy = class {
 };
 
 // src/configuration/execution.ts
-import { logger as logger22 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger23 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG7 = "adapter-stellar-execution-config";
 async function getStellarSupportedExecutionMethods() {
-  logger22.warn(
+  logger23.warn(
     "adapter-stellar-execution-config",
     "getStellarSupportedExecutionMethods is using placeholder implementation."
   );
@@ -3281,11 +3491,11 @@ async function getStellarSupportedExecutionMethods() {
   ]);
 }
 async function _validateMultisigConfig(_config, _walletStatus) {
-  logger22.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
+  logger23.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
   return true;
 }
 async function validateStellarExecutionConfig(config, walletStatus) {
-  logger22.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
+  logger23.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
   switch (config.method) {
     case "eoa":
       return validateEoaConfig(config, walletStatus);
@@ -3295,7 +3505,7 @@ async function validateStellarExecutionConfig(config, walletStatus) {
       return _validateMultisigConfig(config, walletStatus);
     default: {
       const unknownMethod = config.method;
-      logger22.warn(
+      logger23.warn(
         SYSTEM_LOG_TAG7,
         `Unsupported execution method type encountered: ${unknownMethod}`
       );
@@ -3304,121 +3514,6 @@ async function validateStellarExecutionConfig(config, walletStatus) {
   }
 }
 
-// src/configuration/rpc.ts
-import {
-  appConfigService as appConfigService2,
-  isValidUrl,
-  logger as logger23,
-  userRpcConfigService as userRpcConfigService3
-} from "@openzeppelin/ui-builder-utils";
-function validateStellarRpcEndpoint(rpcConfig) {
-  try {
-    if (!isValidUrl(rpcConfig.url)) {
-      logger23.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
-      return false;
-    }
-    return true;
-  } catch (error) {
-    logger23.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
-    return false;
-  }
-}
-async function testStellarRpcConnection(rpcConfig, timeoutMs = 5e3) {
-  if (!rpcConfig.url) {
-    return { success: false, error: "Soroban RPC URL is required" };
-  }
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const startTime = Date.now();
-    const response = await fetch(rpcConfig.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "getHealth"
-      }),
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      return { success: false, error: `HTTP error: ${response.status}` };
-    }
-    const data = await response.json();
-    const latency = Date.now() - startTime;
-    if (data.error) {
-      return {
-        success: false,
-        error: `Soroban RPC error: ${data.error.message || "Unknown RPC error"}`
-      };
-    }
-    if (!data.result) {
-      return await testWithFallbackMethod(rpcConfig, controller.signal, startTime);
-    }
-    const healthStatus = data.result.status;
-    if (healthStatus && healthStatus !== "healthy") {
-      return {
-        success: false,
-        error: `Soroban RPC service unhealthy: ${healthStatus}`,
-        latency
-      };
-    }
-    return { success: true, latency };
-  } catch (error) {
-    logger23.error("testStellarRpcConnection", "Connection test failed:", error);
-    if (error instanceof Error && error.name === "AbortError") {
-      return {
-        success: false,
-        error: `Connection timeout after ${timeoutMs}ms`
-      };
-    }
-    try {
-      return await testWithFallbackMethod(rpcConfig, controller.signal, Date.now());
-    } catch {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Connection failed"
-      };
-    }
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-async function testWithFallbackMethod(rpcConfig, signal, startTime) {
-  const response = await fetch(rpcConfig.url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "getLatestLedger"
-    }),
-    signal
-  });
-  if (!response.ok) {
-    return { success: false, error: `HTTP error: ${response.status}` };
-  }
-  const data = await response.json();
-  const latency = Date.now() - startTime;
-  if (data.error) {
-    return {
-      success: false,
-      error: `Soroban RPC error: ${data.error.message || "Unknown RPC error"}`
-    };
-  }
-  if (data.result && data.result.sequence) {
-    return { success: true, latency };
-  }
-  return {
-    success: false,
-    error: "Unexpected response format from Soroban RPC endpoint"
-  };
-}
-
 // src/mapping/constants.ts
 var STELLAR_TYPE_TO_FIELD_TYPE = {
   // Address types
@@ -4686,7 +4781,24 @@ var StellarAdapter = class {
       `Adapter initialized for network: ${networkConfig.name} (ID: ${networkConfig.id})`
     );
   }
-  // --- Contract Loading --- //
+  /**
+   * @inheritdoc
+   */
+  getNetworkServiceForms() {
+    return getStellarNetworkServiceForms();
+  }
+  /**
+   * @inheritdoc
+   */
+  async validateNetworkServiceConfig(serviceId, values) {
+    return validateStellarNetworkServiceConfig(serviceId, values);
+  }
+  /**
+   * @inheritdoc
+   */
+  async testNetworkServiceConnection(serviceId, values) {
+    return testStellarNetworkServiceConnection(serviceId, values);
+  }
   /**
    * NOTE about artifact inputs (single input with auto-detection):
    *
@@ -4711,6 +4823,9 @@ var StellarAdapter = class {
    *   manual contract definition exactly like the EVM/Midnight flows.
    * - Provide clear UI hints about supported formats (JSON spec or Wasm binary).
    */
+  /**
+   * @inheritdoc
+   */
   getContractDefinitionInputs() {
     return [
       {
@@ -4749,10 +4864,15 @@ var StellarAdapter = class {
       throw error;
     }
   }
+  /**
+   * @inheritdoc
+   */
   getWritableFunctions(contractSchema) {
     return getStellarWritableFunctions(contractSchema);
   }
-  // --- Type Mapping & Field Generation --- //
+  /**
+   * @inheritdoc
+   */
   mapParameterTypeToFieldType(parameterType) {
     return mapStellarParameterTypeToFieldType(parameterType);
   }
@@ -4762,7 +4882,9 @@ var StellarAdapter = class {
   generateDefaultField(parameter, contractSchema) {
     return generateStellarDefaultField(parameter, contractSchema);
   }
-  // --- Transaction Formatting & Execution --- //
+  /**
+   * @inheritdoc
+   */
   formatTransactionData(contractSchema, functionId, submittedInputs, fields) {
     return formatStellarTransactionData(contractSchema, functionId, submittedInputs, fields);
   }
@@ -4775,15 +4897,15 @@ var StellarAdapter = class {
       runtimeApiKey
     );
   }
-  // NOTE: waitForTransactionConfirmation? is optional in the interface.
-  // Since the imported function is currently undefined, we omit the method here.
-  // If implemented in ./transaction/sender.ts later, add the method back:
-  // async waitForTransactionConfirmation?(...) { ... }
-  // --- View Function Querying --- //
+  /**
+   * @inheritdoc
+   */
   isViewFunction(functionDetails) {
     return isStellarViewFunction(functionDetails);
   }
-  // Implement queryViewFunction with the correct signature from ContractAdapter
+  /**
+   * @inheritdoc
+   */
   async queryViewFunction(contractAddress, functionId, params = [], contractSchema) {
     return queryStellarViewFunction(
       contractAddress,
@@ -4794,22 +4916,39 @@ var StellarAdapter = class {
       (address) => this.loadContract({ contractAddress: address })
     );
   }
+  /**
+   * @inheritdoc
+   */
   formatFunctionResult(decodedValue, functionDetails) {
     return formatStellarFunctionResult(decodedValue, functionDetails);
   }
-  // --- Wallet Interaction --- //
+  /**
+   * @inheritdoc
+   */
   supportsWalletConnection() {
     return supportsStellarWalletConnection();
   }
+  /**
+   * @inheritdoc
+   */
   async getAvailableConnectors() {
     return getStellarAvailableConnectors();
   }
+  /**
+   * @inheritdoc
+   */
   async connectWallet(connectorId) {
     return connectStellarWallet(connectorId);
   }
+  /**
+   * @inheritdoc
+   */
   async disconnectWallet() {
     return disconnectStellarWallet();
   }
+  /**
+   * @inheritdoc
+   */
   getWalletConnectionStatus() {
     const impl = getInitializedStellarWalletImplementation();
     if (!impl) {
@@ -4841,29 +4980,43 @@ var StellarAdapter = class {
       }
     );
   }
-  // --- Configuration & Metadata --- //
+  /**
+   * @inheritdoc
+   */
   async getSupportedExecutionMethods() {
     return getStellarSupportedExecutionMethods();
   }
+  /**
+   * @inheritdoc
+   */
   async validateExecutionConfig(config) {
     const walletStatus = this.getWalletConnectionStatus();
     return validateStellarExecutionConfig(config, walletStatus);
   }
-  // Implement getExplorerUrl with the correct signature from ContractAdapter
+  /**
+   * @inheritdoc
+   */
   getExplorerUrl(address) {
     return getStellarExplorerAddressUrl(address, this.networkConfig);
   }
-  // Implement getExplorerTxUrl with the correct signature from ContractAdapter
+  /**
+   * @inheritdoc
+   */
   getExplorerTxUrl(txHash) {
     if (getStellarExplorerTxUrl) {
       return getStellarExplorerTxUrl(txHash, this.networkConfig);
     }
     return null;
   }
-  // --- Validation --- //
+  /**
+   * @inheritdoc
+   */
   isValidAddress(address, addressType) {
     return isValidAddress(address, addressType);
   }
+  /**
+   * @inheritdoc
+   */
   async getAvailableUiKits() {
     return [
       {
@@ -4936,6 +5089,9 @@ var StellarAdapter = class {
   getEcosystemReactHooks() {
     return stellarFacadeHooks;
   }
+  /**
+   * @inheritdoc
+   */
   async getRelayers(serviceUrl, accessToken) {
     const relayerStrategy = new RelayerExecutionStrategy();
     try {
@@ -4945,6 +5101,9 @@ var StellarAdapter = class {
       return Promise.resolve([]);
     }
   }
+  /**
+   * @inheritdoc
+   */
   async getRelayer(serviceUrl, accessToken, relayerId) {
     const relayerStrategy = new RelayerExecutionStrategy();
     try {
@@ -4960,8 +5119,7 @@ var StellarAdapter = class {
     }
   }
   /**
-   * Returns a React component for configuring Stellar-specific relayer transaction options.
-   * @returns The Stellar relayer options component
+   * @inheritdoc
    */
   getRelayerOptionsComponent() {
     return StellarRelayerOptions;