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

package/dist/index.cjs

@@ -47,9 +47,150 @@ module.exports = __toCommonJS(index_exports);
 var import_ui_builder_types6 = require("@openzeppelin/ui-builder-types");
 var import_ui_builder_utils38 = require("@openzeppelin/ui-builder-utils");
 
+// src/configuration/rpc.ts
+var import_ui_builder_utils = require("@openzeppelin/ui-builder-utils");
+function validateStellarRpcEndpoint(rpcConfig) {
+  try {
+    if (!(0, import_ui_builder_utils.isValidUrl)(rpcConfig.url)) {
+      import_ui_builder_utils.logger.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    import_ui_builder_utils.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) {
+    import_ui_builder_utils.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
 var StellarSdk2 = __toESM(require("@stellar/stellar-sdk"), 1);
-var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
 
 // src/validation/address.ts
 var import_stellar_sdk = require("@stellar/stellar-sdk");
@@ -132,7 +273,7 @@ function isValidAddress(address, addressType) {
 }
 
 // src/validation/eoa.ts
-var import_ui_builder_utils = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils2 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG = "StellarEoaValidator";
 async function validateEoaConfig(config, walletStatus) {
   if (!config.allowAny) {
@@ -147,7 +288,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) {
-      import_ui_builder_utils.logger.warn(
+      import_ui_builder_utils2.logger.warn(
         SYSTEM_LOG_TAG,
         "Wallet is connected but address is unavailable for Stellar EOA validation."
       );
@@ -187,11 +328,11 @@ function getStellarExplorerTxUrl(txHash, networkConfig) {
 
 // src/mapping/struct-fields.ts
 var import_stellar_sdk2 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils3 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils4 = require("@openzeppelin/ui-builder-utils");
 
 // src/utils/type-detection.ts
 var StellarSdk = __toESM(require("@stellar/stellar-sdk"), 1);
-var import_ui_builder_utils2 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils3 = require("@openzeppelin/ui-builder-utils");
 function extractSorobanTypeFromScSpec(scSpecType) {
   try {
     const typeSwitch = scSpecType.switch();
@@ -272,7 +413,7 @@ function extractSorobanTypeFromScSpec(scSpecType) {
         return udtType.name().toString();
       }
       default:
-        import_ui_builder_utils2.logger.error("extractSorobanTypeFromScSpec", `\u{1F6A8} MISSING SCSPEC TYPE HANDLER \u{1F6A8}`, {
+        import_ui_builder_utils3.logger.error("extractSorobanTypeFromScSpec", `\u{1F6A8} MISSING SCSPEC TYPE HANDLER \u{1F6A8}`, {
           typeSwitchValue: typeSwitch.value,
           typeSwitchName: typeSwitch.name,
           rawScSpecType: scSpecType,
@@ -286,16 +427,16 @@ function extractSorobanTypeFromScSpec(scSpecType) {
           value: typeSwitch.value,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        if ((0, import_ui_builder_utils2.isDevelopmentOrTestEnvironment)()) {
+        if ((0, import_ui_builder_utils3.isDevelopmentOrTestEnvironment)()) {
           throw new Error(
             `Missing ScSpec type handler: ${typeSwitch.name} (value: ${typeSwitch.value}). Please add support for this type.`
           );
         }
-        import_ui_builder_utils2.logger.error("STELLAR_ADAPTER_MISSING_TYPE", "Missing ScSpec type handler:", errorReport);
+        import_ui_builder_utils3.logger.error("STELLAR_ADAPTER_MISSING_TYPE", "Missing ScSpec type handler:", errorReport);
         return "unknown";
     }
   } catch (error) {
-    import_ui_builder_utils2.logger.error("extractSorobanTypeFromScSpec", "Failed to extract type:", error);
+    import_ui_builder_utils3.logger.error("extractSorobanTypeFromScSpec", "Failed to extract type:", error);
     return "unknown";
   }
 }
@@ -347,7 +488,7 @@ function extractStructFields(entries, structName) {
     }
     return null;
   } catch (error) {
-    import_ui_builder_utils3.logger.error(
+    import_ui_builder_utils4.logger.error(
       "extractStructFields",
       `Failed to extract struct fields for ${structName}:`,
       error
@@ -372,22 +513,22 @@ function isStructType(entries, typeName) {
     const isStruct = entryKind.value === import_stellar_sdk2.xdr.ScSpecEntryKind.scSpecEntryUdtStructV0().value;
     return isStruct;
   } catch (error) {
-    import_ui_builder_utils3.logger.error("isStructType", `Failed to check if ${typeName} is struct:`, error);
+    import_ui_builder_utils4.logger.error("isStructType", `Failed to check if ${typeName} is struct:`, error);
     return false;
   }
 }
 
 // src/query/handler.ts
 var import_stellar_sdk9 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils11 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
 
 // src/transform/parsers/index.ts
 var import_ui_builder_types3 = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils9 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils10 = require("@openzeppelin/ui-builder-utils");
 
 // src/transform/parsers/generic-parser.ts
 var import_ui_builder_types = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils4 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils5 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG2 = "GenericParser";
 function parseGenericType(typeString) {
   const match = typeString.match(/^(\w+)<(.*)>$/);
@@ -486,11 +627,11 @@ function parseGeneric(value, parameterType, parseInnerValue) {
         return value;
       }
       default:
-        import_ui_builder_utils4.logger.warn(SYSTEM_LOG_TAG2, `Unknown generic type: ${baseType}`);
+        import_ui_builder_utils5.logger.warn(SYSTEM_LOG_TAG2, `Unknown generic type: ${baseType}`);
         return null;
     }
   } catch (error) {
-    import_ui_builder_utils4.logger.error(SYSTEM_LOG_TAG2, `Failed to parse generic type ${parameterType}:`, error);
+    import_ui_builder_utils5.logger.error(SYSTEM_LOG_TAG2, `Failed to parse generic type ${parameterType}:`, error);
     throw error;
   }
 }
@@ -501,7 +642,7 @@ function isGenericType(parameterType) {
 
 // src/transform/parsers/primitive-parser.ts
 var import_stellar_sdk3 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils5 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils6 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG3 = "PrimitiveParser";
 function parsePrimitive(value, parameterType) {
   try {
@@ -522,15 +663,15 @@ function parsePrimitive(value, parameterType) {
       case "Bytes":
         if (typeof value === "string") {
           const cleanValue = value.startsWith("0x") ? value.slice(2) : value;
-          const encoding = (0, import_ui_builder_utils5.detectBytesEncoding)(cleanValue);
-          return (0, import_ui_builder_utils5.stringToBytes)(cleanValue, encoding);
+          const encoding = (0, import_ui_builder_utils6.detectBytesEncoding)(cleanValue);
+          return (0, import_ui_builder_utils6.stringToBytes)(cleanValue, encoding);
         }
         throw new Error(`Bytes parameter must be a string, got ${typeof value}`);
       // DataUrl: handle base64 encoded data (similar to Bytes)
       case "DataUrl":
         if (typeof value === "string") {
-          const encoding = (0, import_ui_builder_utils5.detectBytesEncoding)(value);
-          return (0, import_ui_builder_utils5.stringToBytes)(value, encoding);
+          const encoding = (0, import_ui_builder_utils6.detectBytesEncoding)(value);
+          return (0, import_ui_builder_utils6.stringToBytes)(value, encoding);
         }
         throw new Error(`DataUrl parameter must be a string, got ${typeof value}`);
       // Address: validate format
@@ -555,8 +696,8 @@ function parsePrimitive(value, parameterType) {
         if (/^BytesN<\d+>$/.test(parameterType)) {
           if (typeof value === "string") {
             const cleanValue = value.startsWith("0x") ? value.slice(2) : value;
-            const encoding = (0, import_ui_builder_utils5.detectBytesEncoding)(cleanValue);
-            return (0, import_ui_builder_utils5.stringToBytes)(cleanValue, encoding);
+            const encoding = (0, import_ui_builder_utils6.detectBytesEncoding)(cleanValue);
+            return (0, import_ui_builder_utils6.stringToBytes)(cleanValue, encoding);
           }
           throw new Error(`Bytes parameter must be a string, got ${typeof value}`);
         }
@@ -575,7 +716,7 @@ function parsePrimitive(value, parameterType) {
         return null;
     }
   } catch (error) {
-    import_ui_builder_utils5.logger.error(SYSTEM_LOG_TAG3, `Failed to parse primitive ${parameterType}:`, error);
+    import_ui_builder_utils6.logger.error(SYSTEM_LOG_TAG3, `Failed to parse primitive ${parameterType}:`, error);
     throw error;
   }
 }
@@ -585,7 +726,7 @@ function isPrimitiveType(parameterType) {
 
 // src/transform/parsers/complex-parser.ts
 var import_stellar_sdk5 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils7 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils8 = require("@openzeppelin/ui-builder-utils");
 
 // src/utils/safe-type-parser.ts
 var PARSING_LIMITS = {
@@ -771,7 +912,7 @@ function convertStellarTypeToScValType(stellarType) {
 
 // src/utils/input-parsing.ts
 var import_stellar_sdk4 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils6 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils7 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG4 = "StellarInputParsingUtils";
 function isMapArray(argValue) {
   try {
@@ -796,13 +937,13 @@ function getScValFromPrimitive(v) {
     }
     if (v.type === "bytes") {
       const stringValue = v.value;
-      const encoding = (0, import_ui_builder_utils6.detectBytesEncoding)(stringValue);
-      return (0, import_stellar_sdk4.nativeToScVal)((0, import_ui_builder_utils6.stringToBytes)(stringValue, encoding));
+      const encoding = (0, import_ui_builder_utils7.detectBytesEncoding)(stringValue);
+      return (0, import_stellar_sdk4.nativeToScVal)((0, import_ui_builder_utils7.stringToBytes)(stringValue, encoding));
     }
     const typeHint = convertStellarTypeToScValType(v.type);
     return (0, import_stellar_sdk4.nativeToScVal)(v.value, { type: typeHint });
   } catch (error) {
-    import_ui_builder_utils6.logger.error(SYSTEM_LOG_TAG4, `Failed to convert primitive ${v.type}:`, error);
+    import_ui_builder_utils7.logger.error(SYSTEM_LOG_TAG4, `Failed to convert primitive ${v.type}:`, error);
     throw new Error(`Failed to convert primitive value of type ${v.type}: ${error}`);
   }
 }
@@ -849,7 +990,7 @@ function convertEnumToScVal(obj, scVals) {
     const tupleVec = import_stellar_sdk4.xdr.ScVal.scvVec([tagSymbol, ...valuesVal]);
     return tupleVec;
   } catch (error) {
-    import_ui_builder_utils6.logger.error(SYSTEM_LOG_TAG4, "Failed to convert enum:", error);
+    import_ui_builder_utils7.logger.error(SYSTEM_LOG_TAG4, "Failed to convert enum:", error);
     throw new Error(`Failed to convert enum: ${error}`);
   }
 }
@@ -878,7 +1019,7 @@ function convertObjectToMap(mapArray) {
     }, {});
     return { mapVal, mapType };
   } catch (error) {
-    import_ui_builder_utils6.logger.error(SYSTEM_LOG_TAG4, "Failed to convert map:", error);
+    import_ui_builder_utils7.logger.error(SYSTEM_LOG_TAG4, "Failed to convert map:", error);
     throw new Error(`Failed to convert map: ${error}`);
   }
 }
@@ -889,7 +1030,7 @@ var import_ui_builder_types2 = require("@openzeppelin/ui-builder-types");
 
 // src/transform/parsers/struct-parser.ts
 var import_stellar_sdk6 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils8 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils9 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG5 = "StructParser";
 function needsParsing(value, fieldType) {
   if ((fieldType === "Bytes" || fieldType.startsWith("BytesN<")) && value instanceof Uint8Array) {
@@ -910,7 +1051,7 @@ function needsParsing(value, fieldType) {
   if (typeof value === "string") {
     return true;
   }
-  if ((0, import_ui_builder_utils8.isPlainObject)(value)) {
+  if ((0, import_ui_builder_utils9.isPlainObject)(value)) {
     return true;
   }
   return false;
@@ -966,13 +1107,13 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
       );
     }
   }
-  import_ui_builder_utils8.logger.debug(SYSTEM_LOG_TAG5, "convertStructToScVal final values:", {
+  import_ui_builder_utils9.logger.debug(SYSTEM_LOG_TAG5, "convertStructToScVal final values:", {
     parameterType,
     convertedValue,
     typeHints
   });
   const scVal = (0, import_stellar_sdk6.nativeToScVal)(convertedValue, { type: typeHints });
-  import_ui_builder_utils8.logger.debug(SYSTEM_LOG_TAG5, "convertStructToScVal generated ScVal:", {
+  import_ui_builder_utils9.logger.debug(SYSTEM_LOG_TAG5, "convertStructToScVal generated ScVal:", {
     parameterType,
     scValType: scVal.switch().name,
     scValValue: scVal.value()
@@ -980,7 +1121,7 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
   return scVal;
 }
 function isStructType2(value, parameterType) {
-  if (!(0, import_ui_builder_utils8.isPlainObject)(value)) {
+  if (!(0, import_ui_builder_utils9.isPlainObject)(value)) {
     return false;
   }
   const genericInfo = parseGenericType(parameterType);
@@ -1126,7 +1267,7 @@ function parseStellarInput(value, parameterType) {
     if ((0, import_ui_builder_types3.isEnumValue)(value) && isLikelyEnumType(parameterType)) {
       return value;
     }
-    if ((0, import_ui_builder_utils9.isPlainObject)(value)) {
+    if ((0, import_ui_builder_utils10.isPlainObject)(value)) {
       return value;
     }
     if (typeof value === "string" || typeof value === "number") {
@@ -1134,14 +1275,14 @@ function parseStellarInput(value, parameterType) {
     }
     throw new Error(`Unsupported parameter type: ${parameterType} with value type ${typeof value}`);
   } catch (error) {
-    import_ui_builder_utils9.logger.error(SYSTEM_LOG_TAG6, "Failed to parse Stellar input:", error);
+    import_ui_builder_utils10.logger.error(SYSTEM_LOG_TAG6, "Failed to parse Stellar input:", error);
     throw error;
   }
 }
 
 // src/transform/output-formatter.ts
 var import_stellar_sdk8 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils10 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils11 = require("@openzeppelin/ui-builder-utils");
 
 // src/types/artifacts.ts
 function isStellarContractArtifacts(obj) {
@@ -1164,7 +1305,7 @@ function validateAndConvertStellarArtifacts(source) {
 // src/transform/output-formatter.ts
 function formatStellarFunctionResult(result, functionDetails) {
   if (!functionDetails.outputs || !Array.isArray(functionDetails.outputs)) {
-    import_ui_builder_utils10.logger.warn(
+    import_ui_builder_utils11.logger.warn(
       "formatStellarFunctionResult",
       `Output definition missing or invalid for function ${functionDetails.name}.`
     );
@@ -1186,7 +1327,7 @@ function formatStellarFunctionResult(result, functionDetails) {
           valueToFormat = new Uint8Array(valueToFormat);
         }
       } catch (error) {
-        import_ui_builder_utils10.logger.error("formatStellarFunctionResult", "Failed to convert ScVal to native", {
+        import_ui_builder_utils11.logger.error("formatStellarFunctionResult", "Failed to convert ScVal to native", {
           functionName: functionDetails.name,
           error
         });
@@ -1204,7 +1345,7 @@ function formatStellarFunctionResult(result, functionDetails) {
     } else if (typeof valueToFormat === "boolean") {
       return String(valueToFormat);
     } else if (valueToFormat instanceof Uint8Array) {
-      return (0, import_ui_builder_utils10.bytesToHex)(valueToFormat, true);
+      return (0, import_ui_builder_utils11.bytesToHex)(valueToFormat, true);
     } else if (Array.isArray(valueToFormat)) {
       if (valueToFormat.length === 0) {
         return "[]";
@@ -1227,7 +1368,7 @@ function formatStellarFunctionResult(result, functionDetails) {
     }
   } catch (error) {
     const errorMessage = `Error formatting result for ${functionDetails.name}: ${error.message}`;
-    import_ui_builder_utils10.logger.error("formatStellarFunctionResult", errorMessage, {
+    import_ui_builder_utils11.logger.error("formatStellarFunctionResult", errorMessage, {
       functionName: functionDetails.name,
       result,
       error
@@ -1259,12 +1400,12 @@ function getStellarWritableFunctions(contractSchema) {
 
 // src/query/handler.ts
 function getSorobanRpcServer(networkConfig) {
-  const customRpcConfig = import_ui_builder_utils11.userRpcConfigService.getUserRpcConfig(networkConfig.id);
+  const customRpcConfig = import_ui_builder_utils12.userRpcConfigService.getUserRpcConfig(networkConfig.id);
   const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
   if (!rpcUrl) {
     throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
   }
-  import_ui_builder_utils11.logger.info(
+  import_ui_builder_utils12.logger.info(
     "getSorobanRpcServer",
     `Creating Soroban RPC server for ${networkConfig.name} using RPC: ${rpcUrl}`
   );
@@ -1295,12 +1436,12 @@ async function createSimulationTransaction(contractAddress, functionName, args,
     }).addOperation(contract2.call(functionName, ...scValArgs)).setTimeout(30);
     return transaction;
   } catch (error) {
-    import_ui_builder_utils11.logger.error("createSimulationTransaction", "Failed to create simulation transaction:", error);
+    import_ui_builder_utils12.logger.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 = []) {
-  import_ui_builder_utils11.logger.info(
+  import_ui_builder_utils12.logger.info(
     "checkStellarFunctionStateMutability",
     `Checking state mutability for function: ${functionName} on ${contractAddress}`
   );
@@ -1342,7 +1483,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       networkConfig
     );
     const transaction = transactionBuilder.build();
-    import_ui_builder_utils11.logger.debug(
+    import_ui_builder_utils12.logger.debug(
       "checkStellarFunctionStateMutability",
       `[Check ${functionName}] Simulating transaction for state mutability check`
     );
@@ -1350,7 +1491,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
     try {
       simulationResult = await rpcServer.simulateTransaction(transaction);
     } catch (simulationError) {
-      import_ui_builder_utils11.logger.warn(
+      import_ui_builder_utils12.logger.warn(
         "checkStellarFunctionStateMutability",
         `[Check ${functionName}] Simulation failed, assuming function modifies state:`,
         simulationError
@@ -1358,7 +1499,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       return true;
     }
     if (import_stellar_sdk9.rpc.Api.isSimulationError(simulationResult)) {
-      import_ui_builder_utils11.logger.warn(
+      import_ui_builder_utils12.logger.warn(
         "checkStellarFunctionStateMutability",
         `[Check ${functionName}] Simulation error, assuming function modifies state:`,
         simulationResult.error
@@ -1366,7 +1507,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
       return true;
     }
     const hasStateChanges = simulationResult.stateChanges && simulationResult.stateChanges.length > 0;
-    import_ui_builder_utils11.logger.info(
+    import_ui_builder_utils12.logger.info(
       "checkStellarFunctionStateMutability",
       `[Check ${functionName}] State mutability check complete:`,
       {
@@ -1377,7 +1518,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
     );
     return Boolean(hasStateChanges);
   } catch (error) {
-    import_ui_builder_utils11.logger.warn(
+    import_ui_builder_utils12.logger.warn(
       "checkStellarFunctionStateMutability",
       `Failed to check state mutability for ${functionName}, assuming it modifies state:`,
       error
@@ -1386,7 +1527,7 @@ async function checkStellarFunctionStateMutability(contractAddress, functionName
   }
 }
 async function queryStellarViewFunction(contractAddress, functionId, networkConfig, params = [], contractSchema, loadContractFn) {
-  import_ui_builder_utils11.logger.info(
+  import_ui_builder_utils12.logger.info(
     "queryStellarViewFunction",
     `Querying Stellar view function: ${functionId} on ${contractAddress} (${networkConfig.name})`,
     { params }
@@ -1428,7 +1569,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       const rawValue = params[index];
       return parseStellarInput(rawValue, inputParam.type);
     });
-    import_ui_builder_utils11.logger.debug("queryStellarViewFunction", "Parsed Args for contract call:", args);
+    import_ui_builder_utils12.logger.debug("queryStellarViewFunction", "Parsed Args for contract call:", args);
     const paramTypes = expectedInputs.map((input) => input.type);
     const transactionBuilder = await createSimulationTransaction(
       contractAddress,
@@ -1438,7 +1579,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       stellarConfig
     );
     const transaction = transactionBuilder.build();
-    import_ui_builder_utils11.logger.debug(
+    import_ui_builder_utils12.logger.debug(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Simulating transaction:`,
       transaction.toXDR()
@@ -1447,7 +1588,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
     try {
       simulationResult = await rpcServer.simulateTransaction(transaction);
     } catch (simulationError) {
-      import_ui_builder_utils11.logger.error(
+      import_ui_builder_utils12.logger.error(
         "queryStellarViewFunction",
         `[Query ${functionDetails.name}] Simulation failed:`,
         simulationError
@@ -1457,7 +1598,7 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       );
     }
     if (import_stellar_sdk9.rpc.Api.isSimulationError(simulationResult)) {
-      import_ui_builder_utils11.logger.error(
+      import_ui_builder_utils12.logger.error(
         "queryStellarViewFunction",
         `[Query ${functionDetails.name}] Simulation error:`,
         simulationResult.error
@@ -1468,13 +1609,13 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
       throw new Error(`No result returned from contract simulation for ${functionDetails.name}`);
     }
     const rawResult = simulationResult.result.retval;
-    import_ui_builder_utils11.logger.debug(
+    import_ui_builder_utils12.logger.debug(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Raw simulation result:`,
       rawResult
     );
     const formattedResult = formatStellarFunctionResult(rawResult, functionDetails);
-    import_ui_builder_utils11.logger.info(
+    import_ui_builder_utils12.logger.info(
       "queryStellarViewFunction",
       `[Query ${functionDetails.name}] Formatted result:`,
       formattedResult
@@ -1482,7 +1623,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}`;
-    import_ui_builder_utils11.logger.error("queryStellarViewFunction", errorMessage, {
+    import_ui_builder_utils12.logger.error("queryStellarViewFunction", errorMessage, {
       contractAddress,
       functionId,
       params,
@@ -1494,10 +1635,10 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
 }
 
 // src/sac/spec-cache.ts
-var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils15 = require("@openzeppelin/ui-builder-utils");
 
 // src/sac/spec-source.ts
-var import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils13 = require("@openzeppelin/ui-builder-utils");
 var DEFAULT_SPEC = {
   repo: "stellar/stellar-asset-contract-spec",
   path: "refs/heads/main",
@@ -1518,7 +1659,7 @@ async function fetchSacSpecJson(cfg = {}) {
     }
     return await res.text();
   } catch (error) {
-    import_ui_builder_utils12.logger.error("stellar:sac:spec-source", "Failed to fetch SAC spec:", url, error);
+    import_ui_builder_utils13.logger.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.");
   }
 }
@@ -1527,7 +1668,7 @@ async function fetchSacSpecJson(cfg = {}) {
 var import_stellar_sdk10 = require("@stellar/stellar-sdk");
 var import_lossless_json = require("lossless-json");
 var import_package = __toESM(require("@stellar/stellar-xdr-json/package.json"), 1);
-var import_ui_builder_utils13 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
 var stellarXdrJsonVersion = import_package.default.version ?? "23.0.0";
 var CDN_WASM_URL = `https://unpkg.com/@stellar/stellar-xdr-json@${stellarXdrJsonVersion}/stellar_xdr_json_bg.wasm`;
 var initialized = false;
@@ -1541,7 +1682,7 @@ async function ensureXdrJsonInitialized() {
     encode = stellarXdrJson.encode;
     initialized = true;
   } catch (error) {
-    import_ui_builder_utils13.logger.error("stellar:sac:xdr", "Failed to initialize WASM module:", error);
+    import_ui_builder_utils14.logger.error("stellar:sac:xdr", "Failed to initialize WASM module:", error);
     throw error;
   }
 }
@@ -1563,7 +1704,7 @@ async function encodeSacSpecEntries(jsonString) {
     }
     return result;
   } catch (error) {
-    import_ui_builder_utils13.logger.error("stellar:sac:xdr", "Failed to encode SAC spec to XDR", error);
+    import_ui_builder_utils14.logger.error("stellar:sac:xdr", "Failed to encode SAC spec to XDR", error);
     throw new Error("Failed to process SAC spec.");
   }
 }
@@ -1578,7 +1719,7 @@ async function getSacSpecArtifacts(cfg = {}) {
   const cacheKey = getSacSpecUrl(cfg);
   const cached = sacSpecCache.get(cacheKey);
   if (cached) {
-    import_ui_builder_utils14.logger.debug("stellar:sac:spec-cache", "Returning cached SAC spec artifacts");
+    import_ui_builder_utils15.logger.debug("stellar:sac:spec-cache", "Returning cached SAC spec artifacts");
     return cached;
   }
   const inflight = sacSpecInflight.get(cacheKey);
@@ -1595,7 +1736,7 @@ async function getSacSpecArtifacts(cfg = {}) {
     };
     sacSpecCache.set(cacheKey, entry);
     sacSpecInflight.delete(cacheKey);
-    import_ui_builder_utils14.logger.debug("stellar:sac:spec-cache", "Cached SAC spec artifacts for future re-use");
+    import_ui_builder_utils15.logger.debug("stellar:sac:spec-cache", "Cached SAC spec artifacts for future re-use");
     return entry;
   })().catch((error) => {
     sacSpecInflight.delete(cacheKey);
@@ -1607,9 +1748,9 @@ async function getSacSpecArtifacts(cfg = {}) {
 
 // src/contract/type.ts
 var import_stellar_sdk11 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils15 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
 function getSorobanRpcServer2(networkConfig) {
-  const customRpcConfig = import_ui_builder_utils15.userRpcConfigService.getUserRpcConfig(networkConfig.id);
+  const customRpcConfig = import_ui_builder_utils16.userRpcConfigService.getUserRpcConfig(networkConfig.id);
   const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
   if (!rpcUrl) {
     throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
@@ -1640,7 +1781,7 @@ async function getStellarContractType(contractId, networkConfig) {
     if (detected === execStellarAssetType) return "contractExecutableStellarAsset";
     return null;
   } catch (error) {
-    import_ui_builder_utils15.logger.error("stellar:contract-type", "Failed to detect contract type:", error);
+    import_ui_builder_utils16.logger.error("stellar:contract-type", "Failed to detect contract type:", error);
     throw new Error(
       `Something went wrong getting contract type by contract ID. ${error.message}`
     );
@@ -1649,7 +1790,7 @@ async function getStellarContractType(contractId, networkConfig) {
 
 // src/contract/loader.ts
 async function loadStellarContractFromAddress(contractAddress, networkConfig) {
-  import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", "Loading contract:", {
+  import_ui_builder_utils17.logger.info("loadStellarContractFromAddress", "Loading contract:", {
     contractAddress,
     network: networkConfig.name,
     rpcUrl: networkConfig.sorobanRpcUrl,
@@ -1680,7 +1821,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
         };
       }
     } catch (e) {
-      import_ui_builder_utils16.logger.warn(
+      import_ui_builder_utils17.logger.warn(
         "loadStellarContractFromAddress",
         "SAC detection failed, falling back to regular client:",
         e
@@ -1697,12 +1838,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.";
-        import_ui_builder_utils16.logger.error("loadStellarContractFromAddress", friendly);
+        import_ui_builder_utils17.logger.error("loadStellarContractFromAddress", friendly);
         throw new Error(`NO_WASM: ${friendly}`);
       }
       throw e;
     }
-    import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", "Contract client created successfully");
+    import_ui_builder_utils17.logger.info("loadStellarContractFromAddress", "Contract client created successfully");
     let specEntries = [];
     try {
       if (contractClient.spec && typeof contractClient.spec === "object") {
@@ -1717,20 +1858,20 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "entries() method failed:", e);
+            import_ui_builder_utils17.logger.warn("loadStellarContractFromAddress", "entries() method failed:", e);
           }
         }
         if (specEntries.length === 0 && typeof spec.entries === "function") {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
+            import_ui_builder_utils17.logger.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
           }
         }
-        import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
+        import_ui_builder_utils17.logger.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
       }
     } catch (specError) {
-      import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
+      import_ui_builder_utils17.logger.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
     }
     const functions = await extractFunctionsFromSpec(
       contractClient.spec,
@@ -1738,7 +1879,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
       specEntries,
       networkConfig
     );
-    import_ui_builder_utils16.logger.info(
+    import_ui_builder_utils17.logger.info(
       "loadStellarContractFromAddress",
       `Successfully extracted ${functions.length} functions`
     );
@@ -1753,28 +1894,28 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
   } catch (error) {
     const msg = error?.message || String(error);
     if (msg.startsWith("NO_WASM:")) {
-      import_ui_builder_utils16.logger.error("loadStellarContractFromAddress", msg);
+      import_ui_builder_utils17.logger.error("loadStellarContractFromAddress", msg);
       throw new Error(msg);
     }
-    import_ui_builder_utils16.logger.error("loadStellarContractFromAddress", "Failed to load contract:", error);
+    import_ui_builder_utils17.logger.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();
-    import_ui_builder_utils16.logger.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
+    import_ui_builder_utils17.logger.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
     return await Promise.all(
       specFunctions.map(async (func, index) => {
         try {
           const functionName = func.name().toString();
-          import_ui_builder_utils16.logger.info("extractFunctionsFromSpec", `Processing function: ${functionName}`);
+          import_ui_builder_utils17.logger.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") {
-                import_ui_builder_utils16.logger.warn(
+                import_ui_builder_utils17.logger.warn(
                   "extractFunctionsFromSpec",
                   `Unknown type for parameter "${inputName}" in function "${functionName}"`
                 );
@@ -1784,12 +1925,12 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 const structFields = extractStructFields(specEntries, inputType);
                 if (structFields && structFields.length > 0) {
                   components = structFields;
-                  import_ui_builder_utils16.logger.debug(
+                  import_ui_builder_utils17.logger.debug(
                     "extractFunctionsFromSpec",
                     `Extracted ${structFields.length} fields for struct type "${inputType}": ${structFields.map((f) => `${f.name}:${f.type}`).join(", ")}`
                   );
                 } else {
-                  import_ui_builder_utils16.logger.warn(
+                  import_ui_builder_utils17.logger.warn(
                     "extractFunctionsFromSpec",
                     `No fields extracted for struct "${inputType}"`
                   );
@@ -1801,7 +1942,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 ...components && { components }
               };
             } catch (error) {
-              import_ui_builder_utils16.logger.warn(
+              import_ui_builder_utils17.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse input ${inputIndex}:`,
                 error
@@ -1820,7 +1961,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 type: outputType
               };
             } catch (error) {
-              import_ui_builder_utils16.logger.warn(
+              import_ui_builder_utils17.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse output ${outputIndex}:`,
                 error
@@ -1836,7 +1977,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
           if (networkConfig) {
             try {
               const inputTypes = inputs.map((input) => input.type);
-              import_ui_builder_utils16.logger.debug(
+              import_ui_builder_utils17.logger.debug(
                 "extractFunctionsFromSpec",
                 `Checking state mutability for ${functionName} with input types: ${inputTypes.join(", ")}`
               );
@@ -1847,20 +1988,20 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 inputTypes
               );
               stateMutability = modifiesState ? "nonpayable" : "view";
-              import_ui_builder_utils16.logger.info(
+              import_ui_builder_utils17.logger.info(
                 "extractFunctionsFromSpec",
                 `Function ${functionName} state mutability determined:`,
                 { modifiesState, stateMutability }
               );
             } catch (error) {
-              import_ui_builder_utils16.logger.warn(
+              import_ui_builder_utils17.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to determine state mutability for ${functionName}, assuming it modifies state:`,
                 error
               );
             }
           } else {
-            import_ui_builder_utils16.logger.warn(
+            import_ui_builder_utils17.logger.warn(
               "extractFunctionsFromSpec",
               `No network config provided for ${functionName}, assuming it modifies state`
             );
@@ -1878,7 +2019,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
             stateMutability
           };
         } catch (error) {
-          import_ui_builder_utils16.logger.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
+          import_ui_builder_utils17.logger.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
           return {
             id: `function_${index}`,
             name: `function_${index}`,
@@ -1894,7 +2035,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
       })
     );
   } catch (error) {
-    import_ui_builder_utils16.logger.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
+    import_ui_builder_utils17.logger.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
     throw new Error(`Failed to extract functions: ${error.message}`);
   }
 }
@@ -2193,17 +2334,17 @@ var StellarRelayerOptions = ({ options, onChange }) => {
 // src/transaction/relayer.ts
 var import_stellar_sdk12 = require("@stellar/stellar-sdk");
 var import_relayer_sdk = require("@openzeppelin/relayer-sdk");
-var import_ui_builder_utils22 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/connection.ts
-var import_ui_builder_utils21 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils22 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/utils/stellarWalletImplementationManager.ts
-var import_ui_builder_utils18 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/implementation/wallets-kit-implementation.ts
 var import_stellar_wallets_kit = require("@creit.tech/stellar-wallets-kit");
-var import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils18 = require("@openzeppelin/ui-builder-utils");
 var LOG_SYSTEM = "StellarWalletImplementation";
 var WalletsKitImplementation = class {
   /**
@@ -2224,7 +2365,7 @@ var WalletsKitImplementation = class {
     __publicField(this, "currentWalletId", null);
     __publicField(this, "connectionStatusListeners", /* @__PURE__ */ new Set());
     this.networkConfig = networkConfig || null;
-    import_ui_builder_utils17.logger.info(
+    import_ui_builder_utils18.logger.info(
       LOG_SYSTEM,
       "Constructor called. Initial anticipated kitName:",
       initialUiKitConfig?.kitName,
@@ -2232,7 +2373,7 @@ var WalletsKitImplementation = class {
       networkConfig?.name
     );
     this.initialized = true;
-    import_ui_builder_utils17.logger.info(
+    import_ui_builder_utils18.logger.info(
       LOG_SYSTEM,
       "StellarWalletImplementation instance initialized (StellarWalletsKit config creation deferred)."
     );
@@ -2242,10 +2383,10 @@ var WalletsKitImplementation = class {
    * @param config - The Stellar network configuration
    */
   setNetworkConfig(config) {
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Network config updated:", config.name);
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Network config updated:", config.name);
     this.networkConfig = config;
     if (this.activeStellarKit || this.defaultInstanceKit) {
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
     }
   }
   /**
@@ -2255,14 +2396,14 @@ var WalletsKitImplementation = class {
    * @param kit - The StellarWalletsKit object to set as active, or null to clear it.
    */
   setActiveStellarKit(kit) {
-    import_ui_builder_utils17.logger.info(
+    import_ui_builder_utils18.logger.info(
       LOG_SYSTEM,
       "setActiveStellarKit called with kit:",
       kit ? "Valid StellarWalletsKit" : "Null"
     );
     this.activeStellarKit = kit;
     if (this.unsubscribeFromStatusChanges) {
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
     }
   }
   /**
@@ -2271,14 +2412,14 @@ var WalletsKitImplementation = class {
    * @returns A default StellarWalletsKit instance
    */
   createDefaultKit() {
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
     const network = this.getWalletNetwork();
     const kit = new import_stellar_wallets_kit.StellarWalletsKit({
       network,
       selectedWalletId: void 0,
       modules: (0, import_stellar_wallets_kit.allowAllModules)()
     });
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
     return kit;
   }
   /**
@@ -2286,7 +2427,7 @@ var WalletsKitImplementation = class {
    */
   getWalletNetwork() {
     if (!this.networkConfig) {
-      import_ui_builder_utils17.logger.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
+      import_ui_builder_utils18.logger.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
       return import_stellar_wallets_kit.WalletNetwork.TESTNET;
     }
     return this.networkConfig.type === "mainnet" ? import_stellar_wallets_kit.WalletNetwork.PUBLIC : import_stellar_wallets_kit.WalletNetwork.TESTNET;
@@ -2304,7 +2445,7 @@ var WalletsKitImplementation = class {
    */
   async getAvailableConnectors() {
     if (!this.initialized) {
-      import_ui_builder_utils17.logger.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
+      import_ui_builder_utils18.logger.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
       return [];
     }
     try {
@@ -2317,10 +2458,10 @@ var WalletsKitImplementation = class {
         installed: wallet.isAvailable,
         type: wallet.type || "browser"
       }));
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
       return connectors;
     } catch (error) {
-      import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Failed to get available connectors:", error);
+      import_ui_builder_utils18.logger.error(LOG_SYSTEM, "Failed to get available connectors:", error);
       return [];
     }
   }
@@ -2336,7 +2477,7 @@ var WalletsKitImplementation = class {
     try {
       const prevStatus = this.getWalletConnectionStatus();
       const kit = this.getKitToUse();
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
       kit.setWallet(connectorId);
       const result = await kit.getAddress();
       if (result.address) {
@@ -2344,7 +2485,7 @@ var WalletsKitImplementation = class {
         this.currentWalletId = connectorId;
         const newStatus = this.getWalletConnectionStatus();
         this.notifyConnectionListeners(newStatus, prevStatus);
-        import_ui_builder_utils17.logger.info(
+        import_ui_builder_utils18.logger.info(
           LOG_SYSTEM,
           `Successfully connected to wallet: ${connectorId}, address: ${result.address}`
         );
@@ -2360,7 +2501,7 @@ var WalletsKitImplementation = class {
         };
       }
     } catch (error) {
-      import_ui_builder_utils17.logger.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
+      import_ui_builder_utils18.logger.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
       return {
         connected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2377,15 +2518,15 @@ var WalletsKitImplementation = class {
     }
     try {
       const prevStatus = this.getWalletConnectionStatus();
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Disconnecting wallet");
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Disconnecting wallet");
       this.currentAddress = null;
       this.currentWalletId = null;
       const newStatus = this.getWalletConnectionStatus();
       this.notifyConnectionListeners(newStatus, prevStatus);
-      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Successfully disconnected wallet");
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Successfully disconnected wallet");
       return { disconnected: true };
     } catch (error) {
-      import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
+      import_ui_builder_utils18.logger.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
       return {
         disconnected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2418,15 +2559,15 @@ var WalletsKitImplementation = class {
    */
   onWalletConnectionChange(callback) {
     if (!this.initialized) {
-      import_ui_builder_utils17.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
+      import_ui_builder_utils18.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
       return () => {
       };
     }
     this.connectionStatusListeners.add(callback);
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Connection status listener added");
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Connection status listener added");
     return () => {
       this.connectionStatusListeners.delete(callback);
-      import_ui_builder_utils17.logger.debug(LOG_SYSTEM, "Connection status listener removed");
+      import_ui_builder_utils18.logger.debug(LOG_SYSTEM, "Connection status listener removed");
     };
   }
   /**
@@ -2461,7 +2602,7 @@ var WalletsKitImplementation = class {
     }
     const kit = this.getKitToUse();
     const networkPassphrase = this.getWalletNetwork();
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Signing transaction with wallet");
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Signing transaction with wallet");
     return await kit.signTransaction(xdr13, {
       address,
       networkPassphrase
@@ -2475,7 +2616,7 @@ var WalletsKitImplementation = class {
       try {
         listener(currentStatus, previousStatus);
       } catch (error) {
-        import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
+        import_ui_builder_utils18.logger.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
       }
     });
   }
@@ -2488,7 +2629,7 @@ var WalletsKitImplementation = class {
       this.unsubscribeFromStatusChanges = void 0;
     }
     this.connectionStatusListeners.clear();
-    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Cleanup completed");
+    import_ui_builder_utils18.logger.info(LOG_SYSTEM, "Cleanup completed");
   }
 };
 
@@ -2512,17 +2653,17 @@ async function getStellarWalletImplementation(networkConfig) {
   }
   walletImplementationPromise = (async () => {
     try {
-      import_ui_builder_utils18.logger.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
-      const initialUiKitConfig = import_ui_builder_utils18.appConfigService.getTypedNestedConfig(
+      import_ui_builder_utils19.logger.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
+      const initialUiKitConfig = import_ui_builder_utils19.appConfigService.getTypedNestedConfig(
         "walletui",
         "config"
       );
       const instance = new WalletsKitImplementation(networkConfig, initialUiKitConfig);
-      import_ui_builder_utils18.logger.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
+      import_ui_builder_utils19.logger.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
       walletImplementationInstance = instance;
       return instance;
     } catch (error) {
-      import_ui_builder_utils18.logger.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
+      import_ui_builder_utils19.logger.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
       const fallbackInstance = new WalletsKitImplementation(networkConfig);
       walletImplementationInstance = fallbackInstance;
       return fallbackInstance;
@@ -2532,7 +2673,7 @@ async function getStellarWalletImplementation(networkConfig) {
 }
 function getInitializedStellarWalletImplementation() {
   if (!walletImplementationInstance) {
-    import_ui_builder_utils18.logger.warn(
+    import_ui_builder_utils19.logger.warn(
       LOG_SYSTEM2,
       "getInitializedStellarWalletImplementation called before instance was ready."
     );
@@ -2542,7 +2683,7 @@ function getInitializedStellarWalletImplementation() {
 
 // src/wallet/stellar-wallets-kit/stellarUiKitManager.ts
 var import_stellar_wallets_kit2 = require("@creit.tech/stellar-wallets-kit");
-var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils20 = require("@openzeppelin/ui-builder-utils");
 var getInitialState = () => ({
   isConfigured: false,
   isInitializing: false,
@@ -2579,13 +2720,13 @@ function setNetworkConfig(config) {
 }
 function getWalletNetwork(networkConfig) {
   if (!networkConfig) {
-    import_ui_builder_utils19.logger.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
+    import_ui_builder_utils20.logger.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
     return import_stellar_wallets_kit2.WalletNetwork.TESTNET;
   }
   return networkConfig.type === "mainnet" ? import_stellar_wallets_kit2.WalletNetwork.PUBLIC : import_stellar_wallets_kit2.WalletNetwork.TESTNET;
 }
 async function configure(newFullUiKitConfig) {
-  import_ui_builder_utils19.logger.info(
+  import_ui_builder_utils20.logger.info(
     "StellarUiKitManager:configure",
     "Configuring UI kit. New config:",
     newFullUiKitConfig
@@ -2615,7 +2756,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      import_ui_builder_utils19.logger.info(
+      if (state.networkConfig) {
+        try {
+          const impl = await getStellarWalletImplementation(state.networkConfig);
+          impl.setActiveStellarKit(kit);
+          import_ui_builder_utils20.logger.debug(
+            "StellarUiKitManager:configure",
+            "Active kit wired into wallet implementation for stellar-wallets-kit"
+          );
+        } catch (error) {
+          import_ui_builder_utils20.logger.warn(
+            "StellarUiKitManager:configure",
+            "Failed to attach active kit to wallet implementation:",
+            error
+          );
+        }
+      }
+      import_ui_builder_utils20.logger.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured with built-in UI and all wallet modules"
       );
@@ -2629,7 +2786,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      import_ui_builder_utils19.logger.info(
+      if (state.networkConfig) {
+        try {
+          const impl = await getStellarWalletImplementation(state.networkConfig);
+          impl.setActiveStellarKit(kit);
+          import_ui_builder_utils20.logger.debug(
+            "StellarUiKitManager:configure",
+            "Active kit wired into wallet implementation for custom"
+          );
+        } catch (error) {
+          import_ui_builder_utils20.logger.warn(
+            "StellarUiKitManager:configure",
+            "Failed to attach active kit to wallet implementation:",
+            error
+          );
+        }
+      }
+      import_ui_builder_utils20.logger.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured for custom UI components"
       );
@@ -2638,7 +2811,23 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = false;
       state.error = null;
-      import_ui_builder_utils19.logger.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);
+          import_ui_builder_utils20.logger.debug(
+            "StellarUiKitManager:configure",
+            "Active kit cleared from wallet implementation for none"
+          );
+        } catch (error) {
+          import_ui_builder_utils20.logger.warn(
+            "StellarUiKitManager:configure",
+            "Failed to clear active kit from wallet implementation:",
+            error
+          );
+        }
+      }
+      import_ui_builder_utils20.logger.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
     } else {
       throw new Error(`Unknown UI kit name: ${newKitName}`);
     }
@@ -2651,7 +2840,7 @@ async function configure(newFullUiKitConfig) {
     };
     notifyListeners();
   } catch (error) {
-    import_ui_builder_utils19.logger.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
+    import_ui_builder_utils20.logger.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
     state = {
       ...state,
       isInitializing: false,
@@ -2685,9 +2874,7 @@ function generateStellarWalletsKitConfigFile(userConfig) {
 import { 
   StellarWalletsKit, 
   WalletNetwork, 
-  allowAllModules,
-  WalletConnectModule,
-  WalletConnectAllowedMethods
+  allowAllModules
 } from '@creit.tech/stellar-wallets-kit';
 
 /**
@@ -2722,18 +2909,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({
@@ -2755,7 +2931,7 @@ function generateStellarWalletsKitExportables(uiKitConfig) {
 
 // src/wallet/stellar-wallets-kit/StellarWalletsKitConnectButton.tsx
 var import_react3 = require("react");
-var import_ui_builder_utils20 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils21 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 function StellarWalletsKitConnectButton() {
   const containerRef = (0, import_react3.useRef)(null);
@@ -2763,7 +2939,7 @@ function StellarWalletsKitConnectButton() {
     const state2 = stellarUiKitManager.getState();
     const kit = state2.stellarKitProvider;
     if (!kit || !containerRef.current) {
-      import_ui_builder_utils20.logger.error(
+      import_ui_builder_utils21.logger.error(
         "StellarWalletsKitConnectButton",
         "Kit not initialized or container not available"
       );
@@ -2772,10 +2948,28 @@ function StellarWalletsKitConnectButton() {
     kit.createButton({
       container: containerRef.current,
       onConnect: ({ address }) => {
-        import_ui_builder_utils20.logger.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        import_ui_builder_utils21.logger.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        try {
+          setStellarConnectedAddress(address ?? null);
+        } catch (error) {
+          import_ui_builder_utils21.logger.warn(
+            "StellarWalletsKitConnectButton",
+            "Failed to set connected address in adapter implementation:",
+            error
+          );
+        }
       },
       onDisconnect: () => {
-        import_ui_builder_utils20.logger.info("StellarWalletsKitConnectButton", "Disconnected");
+        import_ui_builder_utils21.logger.info("StellarWalletsKitConnectButton", "Disconnected");
+        try {
+          setStellarConnectedAddress(null);
+        } catch (error) {
+          import_ui_builder_utils21.logger.warn(
+            "StellarWalletsKitConnectButton",
+            "Failed to clear connected address in adapter implementation:",
+            error
+          );
+        }
       },
       buttonText: "Connect Wallet"
     });
@@ -2784,10 +2978,10 @@ function StellarWalletsKitConnectButton() {
         try {
           kit.removeButton();
         } catch (error) {
-          import_ui_builder_utils20.logger.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
+          import_ui_builder_utils21.logger.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
         }
       } else {
-        import_ui_builder_utils20.logger.warn(
+        import_ui_builder_utils21.logger.warn(
           "StellarWalletsKitConnectButton",
           "removeButton method not available on kit instance"
         );
@@ -2816,7 +3010,7 @@ async function disconnectStellarWallet() {
 function getStellarWalletConnectionStatus() {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils21.logger.warn(
+    import_ui_builder_utils22.logger.warn(
       "getStellarWalletConnectionStatus",
       "Wallet implementation not ready. Returning default disconnected state."
     );
@@ -2835,10 +3029,21 @@ function getStellarWalletConnectionStatus() {
     walletId: status.walletId
   };
 }
+function setStellarConnectedAddress(address, walletId) {
+  const impl = getInitializedStellarWalletImplementation();
+  if (impl) {
+    impl.updateConnectionStatus(address, walletId);
+  } else {
+    import_ui_builder_utils22.logger.warn(
+      "setStellarConnectedAddress",
+      "Wallet implementation not ready. Cannot update connection status."
+    );
+  }
+}
 function onStellarWalletConnectionChange(callback) {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils21.logger.warn(
+    import_ui_builder_utils22.logger.warn(
       "onStellarWalletConnectionChange",
       "Wallet implementation not ready. Returning no-op."
     );
@@ -2861,7 +3066,7 @@ function onStellarWalletConnectionChange(callback) {
     try {
       callback(currentStatus, previousStatus);
     } catch (error) {
-      import_ui_builder_utils21.logger.error("Error in Stellar connection status listener:", String(error));
+      import_ui_builder_utils22.logger.error("Error in Stellar connection status listener:", String(error));
     }
   });
 }
@@ -2906,7 +3111,7 @@ var RelayerExecutionStrategy = class {
    * @throws If the API call fails or returns an unsuccessful response.
    */
   async getStellarRelayers(serviceUrl, accessToken, networkConfig) {
-    import_ui_builder_utils22.logger.info(
+    import_ui_builder_utils23.logger.info(
       "[StellarRelayer] Getting relayers with access token",
       accessToken.slice(0, 5).padEnd(accessToken.length, "*")
     );
@@ -2954,7 +3159,7 @@ var RelayerExecutionStrategy = class {
    * @throws If any API call fails or returns an unsuccessful response.
    */
   async getStellarRelayer(serviceUrl, accessToken, relayerId, _networkConfig) {
-    import_ui_builder_utils22.logger.info("[StellarRelayer] Getting detailed relayer info", relayerId);
+    import_ui_builder_utils23.logger.info("[StellarRelayer] Getting detailed relayer info", relayerId);
     const sdkConfig = new import_relayer_sdk.Configuration({
       basePath: serviceUrl,
       accessToken
@@ -2964,11 +3169,11 @@ var RelayerExecutionStrategy = class {
       const [relayerResponse, balanceResponse, statusResponse] = await Promise.all([
         relayersApi.getRelayer(relayerId),
         relayersApi.getRelayerBalance(relayerId).catch((err) => {
-          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to fetch balance", err);
+          import_ui_builder_utils23.logger.warn("[StellarRelayer] Failed to fetch balance", err);
           return null;
         }),
         relayersApi.getRelayerStatus(relayerId).catch((err) => {
-          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to fetch status", err);
+          import_ui_builder_utils23.logger.warn("[StellarRelayer] Failed to fetch status", err);
           return null;
         })
       ]);
@@ -2990,7 +3195,7 @@ var RelayerExecutionStrategy = class {
           const balanceInXlm = balanceInStroops / 1e7;
           enhancedDetails.balance = `${balanceInXlm.toFixed(7)} XLM`;
         } catch (error) {
-          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
+          import_ui_builder_utils23.logger.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
           enhancedDetails.balance = String(balanceResponse.data.data.balance);
         }
       }
@@ -3009,13 +3214,13 @@ var RelayerExecutionStrategy = class {
           }
         }
       }
-      import_ui_builder_utils22.logger.info(
+      import_ui_builder_utils23.logger.info(
         "[StellarRelayer] Retrieved enhanced relayer details",
         JSON.stringify(enhancedDetails)
       );
       return enhancedDetails;
     } catch (error) {
-      import_ui_builder_utils22.logger.error(
+      import_ui_builder_utils23.logger.error(
         "[StellarRelayer] Failed to get relayer details",
         error instanceof Error ? error.message : String(error)
       );
@@ -3271,10 +3476,10 @@ var RelayerExecutionStrategy = class {
 };
 
 // src/configuration/execution.ts
-var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG7 = "adapter-stellar-execution-config";
 async function getStellarSupportedExecutionMethods() {
-  import_ui_builder_utils23.logger.warn(
+  import_ui_builder_utils24.logger.warn(
     "adapter-stellar-execution-config",
     "getStellarSupportedExecutionMethods is using placeholder implementation."
   );
@@ -3300,11 +3505,11 @@ async function getStellarSupportedExecutionMethods() {
   ]);
 }
 async function _validateMultisigConfig(_config, _walletStatus) {
-  import_ui_builder_utils23.logger.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
+  import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
   return true;
 }
 async function validateStellarExecutionConfig(config, walletStatus) {
-  import_ui_builder_utils23.logger.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
+  import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
   switch (config.method) {
     case "eoa":
       return validateEoaConfig(config, walletStatus);
@@ -3314,7 +3519,7 @@ async function validateStellarExecutionConfig(config, walletStatus) {
       return _validateMultisigConfig(config, walletStatus);
     default: {
       const unknownMethod = config.method;
-      import_ui_builder_utils23.logger.warn(
+      import_ui_builder_utils24.logger.warn(
         SYSTEM_LOG_TAG7,
         `Unsupported execution method type encountered: ${unknownMethod}`
       );
@@ -3323,116 +3528,6 @@ async function validateStellarExecutionConfig(config, walletStatus) {
   }
 }
 
-// src/configuration/rpc.ts
-var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
-function validateStellarRpcEndpoint(rpcConfig) {
-  try {
-    if (!(0, import_ui_builder_utils24.isValidUrl)(rpcConfig.url)) {
-      import_ui_builder_utils24.logger.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
-      return false;
-    }
-    return true;
-  } catch (error) {
-    import_ui_builder_utils24.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) {
-    import_ui_builder_utils24.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/mapping/constants.ts
 var STELLAR_TYPE_TO_FIELD_TYPE = {
   // Address types
@@ -3443,14 +3538,14 @@ var STELLAR_TYPE_TO_FIELD_TYPE = {
   ScSymbol: "text",
   // Numeric types - unsigned integers
   U32: "number",
-  U64: "number",
-  U128: "number",
-  U256: "number",
+  U64: "bigint",
+  U128: "bigint",
+  U256: "bigint",
   // Numeric types - signed integers
   I32: "number",
-  I64: "number",
-  I128: "number",
-  I256: "number",
+  I64: "bigint",
+  I128: "bigint",
+  I256: "bigint",
   // Boolean type
   Bool: "checkbox",
   // Byte types
@@ -3549,14 +3644,14 @@ function getStellarCompatibleFieldTypes(parameterType) {
     Address: ["blockchain-address", "text"],
     // Unsigned integers
     U32: ["number", "amount", "text"],
-    U64: ["number", "amount", "text"],
-    U128: ["number", "amount", "text"],
-    U256: ["number", "amount", "text"],
+    U64: ["bigint", "number", "amount", "text"],
+    U128: ["bigint", "number", "amount", "text"],
+    U256: ["bigint", "number", "amount", "text"],
     // Signed integers
     I32: ["number", "amount", "text"],
-    I64: ["number", "amount", "text"],
-    I128: ["number", "amount", "text"],
-    I256: ["number", "amount", "text"],
+    I64: ["bigint", "number", "text"],
+    I128: ["bigint", "number", "text"],
+    I256: ["bigint", "number", "text"],
     // Boolean
     Bool: ["checkbox", "select", "radio", "text"],
     // String types
@@ -4687,7 +4782,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):
    *
@@ -4712,6 +4824,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 [
       {
@@ -4750,10 +4865,15 @@ var StellarAdapter = class {
       throw error;
     }
   }
+  /**
+   * @inheritdoc
+   */
   getWritableFunctions(contractSchema) {
     return getStellarWritableFunctions(contractSchema);
   }
-  // --- Type Mapping & Field Generation --- //
+  /**
+   * @inheritdoc
+   */
   mapParameterTypeToFieldType(parameterType) {
     return mapStellarParameterTypeToFieldType(parameterType);
   }
@@ -4763,7 +4883,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);
   }
@@ -4776,15 +4898,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,
@@ -4795,22 +4917,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) {
@@ -4842,29 +4981,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 [
       {
@@ -4937,6 +5090,9 @@ var StellarAdapter = class {
   getEcosystemReactHooks() {
     return stellarFacadeHooks;
   }
+  /**
+   * @inheritdoc
+   */
   async getRelayers(serviceUrl, accessToken) {
     const relayerStrategy = new RelayerExecutionStrategy();
     try {
@@ -4946,6 +5102,9 @@ var StellarAdapter = class {
       return Promise.resolve([]);
     }
   }
+  /**
+   * @inheritdoc
+   */
   async getRelayer(serviceUrl, accessToken, relayerId) {
     const relayerStrategy = new RelayerExecutionStrategy();
     try {
@@ -4961,8 +5120,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;