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

package/dist/index.cjs

@@ -45,11 +45,11 @@ module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
 var import_ui_builder_types6 = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils34 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils38 = require("@openzeppelin/ui-builder-utils");
 
 // src/contract/loader.ts
 var StellarSdk2 = __toESM(require("@stellar/stellar-sdk"), 1);
-var import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
 
 // src/validation/address.ts
 var import_stellar_sdk = require("@stellar/stellar-sdk");
@@ -1493,9 +1493,163 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
   }
 }
 
+// src/sac/spec-cache.ts
+var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
+
+// src/sac/spec-source.ts
+var import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
+var DEFAULT_SPEC = {
+  repo: "stellar/stellar-asset-contract-spec",
+  path: "refs/heads/main",
+  file: "stellar-asset-spec.json"
+};
+function getSacSpecUrl(cfg = {}) {
+  const repo = cfg.repo || DEFAULT_SPEC.repo;
+  const path = cfg.path || DEFAULT_SPEC.path;
+  const file = cfg.file || DEFAULT_SPEC.file;
+  return `https://raw.githubusercontent.com/${repo}/${path}/${file}`;
+}
+async function fetchSacSpecJson(cfg = {}) {
+  const url = getSacSpecUrl(cfg);
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}`);
+    }
+    return await res.text();
+  } catch (error) {
+    import_ui_builder_utils12.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.");
+  }
+}
+
+// src/sac/xdr.ts
+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 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;
+var encode = null;
+async function ensureXdrJsonInitialized() {
+  if (initialized) return;
+  try {
+    const stellarXdrJson = await import("@stellar/stellar-xdr-json");
+    const init = stellarXdrJson.default;
+    await init(CDN_WASM_URL);
+    encode = stellarXdrJson.encode;
+    initialized = true;
+  } catch (error) {
+    import_ui_builder_utils13.logger.error("stellar:sac:xdr", "Failed to initialize WASM module:", error);
+    throw error;
+  }
+}
+async function encodeSacSpecEntries(jsonString) {
+  await ensureXdrJsonInitialized();
+  if (!encode) {
+    throw new Error("WASM module not properly initialized");
+  }
+  try {
+    const jsonData = (0, import_lossless_json.parse)(jsonString);
+    const result = [];
+    for (const entry of jsonData) {
+      const stringified = (0, import_lossless_json.stringify)(entry);
+      if (!stringified) {
+        throw new Error("Failed to stringify SAC spec entry before XDR encoding.");
+      }
+      const encoded = encode("ScSpecEntry", stringified);
+      result.push(encoded);
+    }
+    return result;
+  } catch (error) {
+    import_ui_builder_utils13.logger.error("stellar:sac:xdr", "Failed to encode SAC spec to XDR", error);
+    throw new Error("Failed to process SAC spec.");
+  }
+}
+function toScSpecEntries(base64Entries) {
+  return base64Entries.map((b64) => import_stellar_sdk10.xdr.ScSpecEntry.fromXDR(b64, "base64"));
+}
+
+// src/sac/spec-cache.ts
+var sacSpecCache = /* @__PURE__ */ new Map();
+var sacSpecInflight = /* @__PURE__ */ new Map();
+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");
+    return cached;
+  }
+  const inflight = sacSpecInflight.get(cacheKey);
+  if (inflight) {
+    return inflight;
+  }
+  const promise = (async () => {
+    const json = await fetchSacSpecJson(cfg);
+    const base64Entries = await encodeSacSpecEntries(json);
+    const specEntries = toScSpecEntries(base64Entries);
+    const entry = {
+      base64Entries,
+      specEntries
+    };
+    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");
+    return entry;
+  })().catch((error) => {
+    sacSpecInflight.delete(cacheKey);
+    throw error;
+  });
+  sacSpecInflight.set(cacheKey, promise);
+  return promise;
+}
+
+// src/contract/type.ts
+var import_stellar_sdk11 = require("@stellar/stellar-sdk");
+var import_ui_builder_utils15 = require("@openzeppelin/ui-builder-utils");
+function getSorobanRpcServer2(networkConfig) {
+  const customRpcConfig = import_ui_builder_utils15.userRpcConfigService.getUserRpcConfig(networkConfig.id);
+  const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
+  if (!rpcUrl) {
+    throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
+  }
+  const allowHttp = new URL(rpcUrl).hostname === "localhost";
+  return new import_stellar_sdk11.rpc.Server(rpcUrl, { allowHttp });
+}
+async function getStellarContractType(contractId, networkConfig) {
+  try {
+    if (!contractId) {
+      return null;
+    }
+    const rpcServer = getSorobanRpcServer2(networkConfig);
+    const ledgerKey = new import_stellar_sdk11.Contract(contractId).getFootprint();
+    const ledgerEntries = await rpcServer.getLedgerEntries(ledgerKey);
+    const first = ledgerEntries?.entries?.[0]?.val;
+    if (!first) {
+      throw new Error("Could not obtain contract data from server.");
+    }
+    const executable = first.contractData()?.val()?.instance()?.executable();
+    if (!executable) {
+      throw new Error("Could not get executable from contract data.");
+    }
+    const execWasmType = import_stellar_sdk11.xdr.ContractExecutableType.contractExecutableWasm().name;
+    const execStellarAssetType = import_stellar_sdk11.xdr.ContractExecutableType.contractExecutableStellarAsset().name;
+    const detected = executable.switch()?.name;
+    if (detected === execWasmType) return "contractExecutableWasm";
+    if (detected === execStellarAssetType) return "contractExecutableStellarAsset";
+    return null;
+  } catch (error) {
+    import_ui_builder_utils15.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}`
+    );
+  }
+}
+
 // src/contract/loader.ts
 async function loadStellarContractFromAddress(contractAddress, networkConfig) {
-  import_ui_builder_utils12.logger.info("loadStellarContractFromAddress", "Loading contract:", {
+  import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", "Loading contract:", {
     contractAddress,
     network: networkConfig.name,
     rpcUrl: networkConfig.sorobanRpcUrl,
@@ -1505,6 +1659,33 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
     if (!StellarSdk2.StrKey.isValidContract(contractAddress)) {
       throw new Error(`Invalid contract address: ${contractAddress}`);
     }
+    try {
+      const execType = await getStellarContractType(contractAddress, networkConfig);
+      if (execType === "contractExecutableStellarAsset") {
+        const { base64Entries, specEntries: specEntries2 } = await getSacSpecArtifacts();
+        const spec = new StellarSdk2.contract.Spec(base64Entries);
+        const functions2 = await extractFunctionsFromSpec(
+          spec,
+          contractAddress,
+          specEntries2,
+          networkConfig
+        );
+        return {
+          name: `Stellar Asset Contract ${contractAddress.slice(0, 8)}...`,
+          ecosystem: "stellar",
+          functions: functions2,
+          metadata: {
+            specEntries: specEntries2
+          }
+        };
+      }
+    } catch (e) {
+      import_ui_builder_utils16.logger.warn(
+        "loadStellarContractFromAddress",
+        "SAC detection failed, falling back to regular client:",
+        e
+      );
+    }
     let contractClient;
     try {
       contractClient = await StellarSdk2.contract.Client.from({
@@ -1516,12 +1697,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_utils12.logger.error("loadStellarContractFromAddress", friendly);
+        import_ui_builder_utils16.logger.error("loadStellarContractFromAddress", friendly);
         throw new Error(`NO_WASM: ${friendly}`);
       }
       throw e;
     }
-    import_ui_builder_utils12.logger.info("loadStellarContractFromAddress", "Contract client created successfully");
+    import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", "Contract client created successfully");
     let specEntries = [];
     try {
       if (contractClient.spec && typeof contractClient.spec === "object") {
@@ -1536,20 +1717,20 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            import_ui_builder_utils12.logger.warn("loadStellarContractFromAddress", "entries() method failed:", e);
+            import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "entries() method failed:", e);
           }
         }
         if (specEntries.length === 0 && typeof spec.entries === "function") {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            import_ui_builder_utils12.logger.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
+            import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
           }
         }
-        import_ui_builder_utils12.logger.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
+        import_ui_builder_utils16.logger.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
       }
     } catch (specError) {
-      import_ui_builder_utils12.logger.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
+      import_ui_builder_utils16.logger.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
     }
     const functions = await extractFunctionsFromSpec(
       contractClient.spec,
@@ -1557,7 +1738,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
       specEntries,
       networkConfig
     );
-    import_ui_builder_utils12.logger.info(
+    import_ui_builder_utils16.logger.info(
       "loadStellarContractFromAddress",
       `Successfully extracted ${functions.length} functions`
     );
@@ -1572,28 +1753,28 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
   } catch (error) {
     const msg = error?.message || String(error);
     if (msg.startsWith("NO_WASM:")) {
-      import_ui_builder_utils12.logger.error("loadStellarContractFromAddress", msg);
+      import_ui_builder_utils16.logger.error("loadStellarContractFromAddress", msg);
       throw new Error(msg);
     }
-    import_ui_builder_utils12.logger.error("loadStellarContractFromAddress", "Failed to load contract:", error);
+    import_ui_builder_utils16.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_utils12.logger.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
+    import_ui_builder_utils16.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_utils12.logger.info("extractFunctionsFromSpec", `Processing function: ${functionName}`);
+          import_ui_builder_utils16.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_utils12.logger.warn(
+                import_ui_builder_utils16.logger.warn(
                   "extractFunctionsFromSpec",
                   `Unknown type for parameter "${inputName}" in function "${functionName}"`
                 );
@@ -1603,12 +1784,12 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 const structFields = extractStructFields(specEntries, inputType);
                 if (structFields && structFields.length > 0) {
                   components = structFields;
-                  import_ui_builder_utils12.logger.debug(
+                  import_ui_builder_utils16.logger.debug(
                     "extractFunctionsFromSpec",
                     `Extracted ${structFields.length} fields for struct type "${inputType}": ${structFields.map((f) => `${f.name}:${f.type}`).join(", ")}`
                   );
                 } else {
-                  import_ui_builder_utils12.logger.warn(
+                  import_ui_builder_utils16.logger.warn(
                     "extractFunctionsFromSpec",
                     `No fields extracted for struct "${inputType}"`
                   );
@@ -1620,7 +1801,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 ...components && { components }
               };
             } catch (error) {
-              import_ui_builder_utils12.logger.warn(
+              import_ui_builder_utils16.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse input ${inputIndex}:`,
                 error
@@ -1639,7 +1820,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 type: outputType
               };
             } catch (error) {
-              import_ui_builder_utils12.logger.warn(
+              import_ui_builder_utils16.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse output ${outputIndex}:`,
                 error
@@ -1655,7 +1836,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
           if (networkConfig) {
             try {
               const inputTypes = inputs.map((input) => input.type);
-              import_ui_builder_utils12.logger.debug(
+              import_ui_builder_utils16.logger.debug(
                 "extractFunctionsFromSpec",
                 `Checking state mutability for ${functionName} with input types: ${inputTypes.join(", ")}`
               );
@@ -1666,20 +1847,20 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 inputTypes
               );
               stateMutability = modifiesState ? "nonpayable" : "view";
-              import_ui_builder_utils12.logger.info(
+              import_ui_builder_utils16.logger.info(
                 "extractFunctionsFromSpec",
                 `Function ${functionName} state mutability determined:`,
                 { modifiesState, stateMutability }
               );
             } catch (error) {
-              import_ui_builder_utils12.logger.warn(
+              import_ui_builder_utils16.logger.warn(
                 "extractFunctionsFromSpec",
                 `Failed to determine state mutability for ${functionName}, assuming it modifies state:`,
                 error
               );
             }
           } else {
-            import_ui_builder_utils12.logger.warn(
+            import_ui_builder_utils16.logger.warn(
               "extractFunctionsFromSpec",
               `No network config provided for ${functionName}, assuming it modifies state`
             );
@@ -1697,7 +1878,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
             stateMutability
           };
         } catch (error) {
-          import_ui_builder_utils12.logger.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
+          import_ui_builder_utils16.logger.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
           return {
             id: `function_${index}`,
             name: `function_${index}`,
@@ -1713,7 +1894,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
       })
     );
   } catch (error) {
-    import_ui_builder_utils12.logger.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
+    import_ui_builder_utils16.logger.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
     throw new Error(`Failed to extract functions: ${error.message}`);
   }
 }
@@ -2010,19 +2191,19 @@ var StellarRelayerOptions = ({ options, onChange }) => {
 };
 
 // src/transaction/relayer.ts
-var import_stellar_sdk10 = require("@stellar/stellar-sdk");
+var import_stellar_sdk12 = require("@stellar/stellar-sdk");
 var import_relayer_sdk = require("@openzeppelin/relayer-sdk");
-var import_ui_builder_utils18 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils22 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/connection.ts
-var import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils21 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/utils/stellarWalletImplementationManager.ts
-var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils18 = 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_utils13 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
 var LOG_SYSTEM = "StellarWalletImplementation";
 var WalletsKitImplementation = class {
   /**
@@ -2043,7 +2224,7 @@ var WalletsKitImplementation = class {
     __publicField(this, "currentWalletId", null);
     __publicField(this, "connectionStatusListeners", /* @__PURE__ */ new Set());
     this.networkConfig = networkConfig || null;
-    import_ui_builder_utils13.logger.info(
+    import_ui_builder_utils17.logger.info(
       LOG_SYSTEM,
       "Constructor called. Initial anticipated kitName:",
       initialUiKitConfig?.kitName,
@@ -2051,7 +2232,7 @@ var WalletsKitImplementation = class {
       networkConfig?.name
     );
     this.initialized = true;
-    import_ui_builder_utils13.logger.info(
+    import_ui_builder_utils17.logger.info(
       LOG_SYSTEM,
       "StellarWalletImplementation instance initialized (StellarWalletsKit config creation deferred)."
     );
@@ -2061,10 +2242,10 @@ var WalletsKitImplementation = class {
    * @param config - The Stellar network configuration
    */
   setNetworkConfig(config) {
-    import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Network config updated:", config.name);
+    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Network config updated:", config.name);
     this.networkConfig = config;
     if (this.activeStellarKit || this.defaultInstanceKit) {
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
     }
   }
   /**
@@ -2074,14 +2255,14 @@ var WalletsKitImplementation = class {
    * @param kit - The StellarWalletsKit object to set as active, or null to clear it.
    */
   setActiveStellarKit(kit) {
-    import_ui_builder_utils13.logger.info(
+    import_ui_builder_utils17.logger.info(
       LOG_SYSTEM,
       "setActiveStellarKit called with kit:",
       kit ? "Valid StellarWalletsKit" : "Null"
     );
     this.activeStellarKit = kit;
     if (this.unsubscribeFromStatusChanges) {
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
     }
   }
   /**
@@ -2090,14 +2271,14 @@ var WalletsKitImplementation = class {
    * @returns A default StellarWalletsKit instance
    */
   createDefaultKit() {
-    import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
+    import_ui_builder_utils17.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_utils13.logger.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
+    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
     return kit;
   }
   /**
@@ -2105,7 +2286,7 @@ var WalletsKitImplementation = class {
    */
   getWalletNetwork() {
     if (!this.networkConfig) {
-      import_ui_builder_utils13.logger.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
+      import_ui_builder_utils17.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;
@@ -2123,7 +2304,7 @@ var WalletsKitImplementation = class {
    */
   async getAvailableConnectors() {
     if (!this.initialized) {
-      import_ui_builder_utils13.logger.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
+      import_ui_builder_utils17.logger.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
       return [];
     }
     try {
@@ -2136,10 +2317,10 @@ var WalletsKitImplementation = class {
         installed: wallet.isAvailable,
         type: wallet.type || "browser"
       }));
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
       return connectors;
     } catch (error) {
-      import_ui_builder_utils13.logger.error(LOG_SYSTEM, "Failed to get available connectors:", error);
+      import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Failed to get available connectors:", error);
       return [];
     }
   }
@@ -2155,7 +2336,7 @@ var WalletsKitImplementation = class {
     try {
       const prevStatus = this.getWalletConnectionStatus();
       const kit = this.getKitToUse();
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
       kit.setWallet(connectorId);
       const result = await kit.getAddress();
       if (result.address) {
@@ -2163,7 +2344,7 @@ var WalletsKitImplementation = class {
         this.currentWalletId = connectorId;
         const newStatus = this.getWalletConnectionStatus();
         this.notifyConnectionListeners(newStatus, prevStatus);
-        import_ui_builder_utils13.logger.info(
+        import_ui_builder_utils17.logger.info(
           LOG_SYSTEM,
           `Successfully connected to wallet: ${connectorId}, address: ${result.address}`
         );
@@ -2179,7 +2360,7 @@ var WalletsKitImplementation = class {
         };
       }
     } catch (error) {
-      import_ui_builder_utils13.logger.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
+      import_ui_builder_utils17.logger.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
       return {
         connected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2196,15 +2377,15 @@ var WalletsKitImplementation = class {
     }
     try {
       const prevStatus = this.getWalletConnectionStatus();
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Disconnecting wallet");
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Disconnecting wallet");
       this.currentAddress = null;
       this.currentWalletId = null;
       const newStatus = this.getWalletConnectionStatus();
       this.notifyConnectionListeners(newStatus, prevStatus);
-      import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Successfully disconnected wallet");
+      import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Successfully disconnected wallet");
       return { disconnected: true };
     } catch (error) {
-      import_ui_builder_utils13.logger.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
+      import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
       return {
         disconnected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2237,15 +2418,15 @@ var WalletsKitImplementation = class {
    */
   onWalletConnectionChange(callback) {
     if (!this.initialized) {
-      import_ui_builder_utils13.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
+      import_ui_builder_utils17.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
       return () => {
       };
     }
     this.connectionStatusListeners.add(callback);
-    import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Connection status listener added");
+    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Connection status listener added");
     return () => {
       this.connectionStatusListeners.delete(callback);
-      import_ui_builder_utils13.logger.debug(LOG_SYSTEM, "Connection status listener removed");
+      import_ui_builder_utils17.logger.debug(LOG_SYSTEM, "Connection status listener removed");
     };
   }
   /**
@@ -2274,14 +2455,14 @@ var WalletsKitImplementation = class {
    * @param address - The account address
    * @returns Promise resolving to signed transaction
    */
-  async signTransaction(xdr11, address) {
+  async signTransaction(xdr13, address) {
     if (!this.initialized) {
       throw new Error("Wallet implementation not initialized");
     }
     const kit = this.getKitToUse();
     const networkPassphrase = this.getWalletNetwork();
-    import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Signing transaction with wallet");
-    return await kit.signTransaction(xdr11, {
+    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Signing transaction with wallet");
+    return await kit.signTransaction(xdr13, {
       address,
       networkPassphrase
     });
@@ -2294,7 +2475,7 @@ var WalletsKitImplementation = class {
       try {
         listener(currentStatus, previousStatus);
       } catch (error) {
-        import_ui_builder_utils13.logger.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
+        import_ui_builder_utils17.logger.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
       }
     });
   }
@@ -2307,7 +2488,7 @@ var WalletsKitImplementation = class {
       this.unsubscribeFromStatusChanges = void 0;
     }
     this.connectionStatusListeners.clear();
-    import_ui_builder_utils13.logger.info(LOG_SYSTEM, "Cleanup completed");
+    import_ui_builder_utils17.logger.info(LOG_SYSTEM, "Cleanup completed");
   }
 };
 
@@ -2331,17 +2512,17 @@ async function getStellarWalletImplementation(networkConfig) {
   }
   walletImplementationPromise = (async () => {
     try {
-      import_ui_builder_utils14.logger.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
-      const initialUiKitConfig = import_ui_builder_utils14.appConfigService.getTypedNestedConfig(
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
+      const initialUiKitConfig = import_ui_builder_utils18.appConfigService.getTypedNestedConfig(
         "walletui",
         "config"
       );
       const instance = new WalletsKitImplementation(networkConfig, initialUiKitConfig);
-      import_ui_builder_utils14.logger.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
+      import_ui_builder_utils18.logger.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
       walletImplementationInstance = instance;
       return instance;
     } catch (error) {
-      import_ui_builder_utils14.logger.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
+      import_ui_builder_utils18.logger.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
       const fallbackInstance = new WalletsKitImplementation(networkConfig);
       walletImplementationInstance = fallbackInstance;
       return fallbackInstance;
@@ -2351,7 +2532,7 @@ async function getStellarWalletImplementation(networkConfig) {
 }
 function getInitializedStellarWalletImplementation() {
   if (!walletImplementationInstance) {
-    import_ui_builder_utils14.logger.warn(
+    import_ui_builder_utils18.logger.warn(
       LOG_SYSTEM2,
       "getInitializedStellarWalletImplementation called before instance was ready."
     );
@@ -2361,7 +2542,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_utils15 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
 var getInitialState = () => ({
   isConfigured: false,
   isInitializing: false,
@@ -2398,13 +2579,13 @@ function setNetworkConfig(config) {
 }
 function getWalletNetwork(networkConfig) {
   if (!networkConfig) {
-    import_ui_builder_utils15.logger.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
+    import_ui_builder_utils19.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_utils15.logger.info(
+  import_ui_builder_utils19.logger.info(
     "StellarUiKitManager:configure",
     "Configuring UI kit. New config:",
     newFullUiKitConfig
@@ -2434,7 +2615,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      import_ui_builder_utils15.logger.info(
+      import_ui_builder_utils19.logger.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured with built-in UI and all wallet modules"
       );
@@ -2448,7 +2629,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      import_ui_builder_utils15.logger.info(
+      import_ui_builder_utils19.logger.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured for custom UI components"
       );
@@ -2457,7 +2638,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = false;
       state.error = null;
-      import_ui_builder_utils15.logger.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
+      import_ui_builder_utils19.logger.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
     } else {
       throw new Error(`Unknown UI kit name: ${newKitName}`);
     }
@@ -2470,7 +2651,7 @@ async function configure(newFullUiKitConfig) {
     };
     notifyListeners();
   } catch (error) {
-    import_ui_builder_utils15.logger.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
+    import_ui_builder_utils19.logger.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
     state = {
       ...state,
       isInitializing: false,
@@ -2574,7 +2755,7 @@ function generateStellarWalletsKitExportables(uiKitConfig) {
 
 // src/wallet/stellar-wallets-kit/StellarWalletsKitConnectButton.tsx
 var import_react3 = require("react");
-var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils20 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 function StellarWalletsKitConnectButton() {
   const containerRef = (0, import_react3.useRef)(null);
@@ -2582,7 +2763,7 @@ function StellarWalletsKitConnectButton() {
     const state2 = stellarUiKitManager.getState();
     const kit = state2.stellarKitProvider;
     if (!kit || !containerRef.current) {
-      import_ui_builder_utils16.logger.error(
+      import_ui_builder_utils20.logger.error(
         "StellarWalletsKitConnectButton",
         "Kit not initialized or container not available"
       );
@@ -2591,10 +2772,10 @@ function StellarWalletsKitConnectButton() {
     kit.createButton({
       container: containerRef.current,
       onConnect: ({ address }) => {
-        import_ui_builder_utils16.logger.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        import_ui_builder_utils20.logger.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
       },
       onDisconnect: () => {
-        import_ui_builder_utils16.logger.info("StellarWalletsKitConnectButton", "Disconnected");
+        import_ui_builder_utils20.logger.info("StellarWalletsKitConnectButton", "Disconnected");
       },
       buttonText: "Connect Wallet"
     });
@@ -2603,10 +2784,10 @@ function StellarWalletsKitConnectButton() {
         try {
           kit.removeButton();
         } catch (error) {
-          import_ui_builder_utils16.logger.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
+          import_ui_builder_utils20.logger.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
         }
       } else {
-        import_ui_builder_utils16.logger.warn(
+        import_ui_builder_utils20.logger.warn(
           "StellarWalletsKitConnectButton",
           "removeButton method not available on kit instance"
         );
@@ -2635,7 +2816,7 @@ async function disconnectStellarWallet() {
 function getStellarWalletConnectionStatus() {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils17.logger.warn(
+    import_ui_builder_utils21.logger.warn(
       "getStellarWalletConnectionStatus",
       "Wallet implementation not ready. Returning default disconnected state."
     );
@@ -2657,7 +2838,7 @@ function getStellarWalletConnectionStatus() {
 function onStellarWalletConnectionChange(callback) {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils17.logger.warn(
+    import_ui_builder_utils21.logger.warn(
       "onStellarWalletConnectionChange",
       "Wallet implementation not ready. Returning no-op."
     );
@@ -2680,13 +2861,13 @@ function onStellarWalletConnectionChange(callback) {
     try {
       callback(currentStatus, previousStatus);
     } catch (error) {
-      import_ui_builder_utils17.logger.error("Error in Stellar connection status listener:", String(error));
+      import_ui_builder_utils21.logger.error("Error in Stellar connection status listener:", String(error));
     }
   });
 }
-async function signTransaction(xdr11, address) {
+async function signTransaction(xdr13, address) {
   const impl = await getStellarWalletImplementation();
-  return impl.signTransaction(xdr11, address);
+  return impl.signTransaction(xdr13, address);
 }
 
 // src/transaction/relayer.ts
@@ -2725,7 +2906,7 @@ var RelayerExecutionStrategy = class {
    * @throws If the API call fails or returns an unsuccessful response.
    */
   async getStellarRelayers(serviceUrl, accessToken, networkConfig) {
-    import_ui_builder_utils18.logger.info(
+    import_ui_builder_utils22.logger.info(
       "[StellarRelayer] Getting relayers with access token",
       accessToken.slice(0, 5).padEnd(accessToken.length, "*")
     );
@@ -2773,7 +2954,7 @@ var RelayerExecutionStrategy = class {
    * @throws If any API call fails or returns an unsuccessful response.
    */
   async getStellarRelayer(serviceUrl, accessToken, relayerId, _networkConfig) {
-    import_ui_builder_utils18.logger.info("[StellarRelayer] Getting detailed relayer info", relayerId);
+    import_ui_builder_utils22.logger.info("[StellarRelayer] Getting detailed relayer info", relayerId);
     const sdkConfig = new import_relayer_sdk.Configuration({
       basePath: serviceUrl,
       accessToken
@@ -2783,11 +2964,11 @@ var RelayerExecutionStrategy = class {
       const [relayerResponse, balanceResponse, statusResponse] = await Promise.all([
         relayersApi.getRelayer(relayerId),
         relayersApi.getRelayerBalance(relayerId).catch((err) => {
-          import_ui_builder_utils18.logger.warn("[StellarRelayer] Failed to fetch balance", err);
+          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to fetch balance", err);
           return null;
         }),
         relayersApi.getRelayerStatus(relayerId).catch((err) => {
-          import_ui_builder_utils18.logger.warn("[StellarRelayer] Failed to fetch status", err);
+          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to fetch status", err);
           return null;
         })
       ]);
@@ -2809,7 +2990,7 @@ var RelayerExecutionStrategy = class {
           const balanceInXlm = balanceInStroops / 1e7;
           enhancedDetails.balance = `${balanceInXlm.toFixed(7)} XLM`;
         } catch (error) {
-          import_ui_builder_utils18.logger.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
+          import_ui_builder_utils22.logger.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
           enhancedDetails.balance = String(balanceResponse.data.data.balance);
         }
       }
@@ -2828,13 +3009,13 @@ var RelayerExecutionStrategy = class {
           }
         }
       }
-      import_ui_builder_utils18.logger.info(
+      import_ui_builder_utils22.logger.info(
         "[StellarRelayer] Retrieved enhanced relayer details",
         JSON.stringify(enhancedDetails)
       );
       return enhancedDetails;
     } catch (error) {
-      import_ui_builder_utils18.logger.error(
+      import_ui_builder_utils22.logger.error(
         "[StellarRelayer] Failed to get relayer details",
         error instanceof Error ? error.message : String(error)
       );
@@ -2921,10 +3102,10 @@ var RelayerExecutionStrategy = class {
     const rpcServer = this.getSorobanRpcServer(stellarConfig);
     const connectedAddress = this.getConnectedWalletAddress();
     const accountResponse = await rpcServer.getAccount(connectedAddress);
-    const sourceAccount = new import_stellar_sdk10.Account(connectedAddress, accountResponse.sequenceNumber());
-    const contract2 = new import_stellar_sdk10.Contract(txData.contractAddress);
-    const transactionBuilder = new import_stellar_sdk10.TransactionBuilder(sourceAccount, {
-      fee: import_stellar_sdk10.BASE_FEE,
+    const sourceAccount = new import_stellar_sdk12.Account(connectedAddress, accountResponse.sequenceNumber());
+    const contract2 = new import_stellar_sdk12.Contract(txData.contractAddress);
+    const transactionBuilder = new import_stellar_sdk12.TransactionBuilder(sourceAccount, {
+      fee: import_stellar_sdk12.BASE_FEE,
       networkPassphrase: stellarConfig.networkPassphrase
     });
     const scValArgs = txData.args.map((arg, index) => {
@@ -2936,12 +3117,12 @@ var RelayerExecutionStrategy = class {
     transactionBuilder.setTimeout(30);
     let transaction = transactionBuilder.build();
     const simulation = await rpcServer.simulateTransaction(transaction);
-    if (import_stellar_sdk10.rpc.Api.isSimulationError(simulation)) {
+    if (import_stellar_sdk12.rpc.Api.isSimulationError(simulation)) {
       throw new Error(`Transaction simulation failed: ${simulation.error}`);
     }
     transaction = await rpcServer.prepareTransaction(transaction);
     const signResult = await signTransaction(transaction.toXDR(), connectedAddress);
-    const signedTx = import_stellar_sdk10.TransactionBuilder.fromXDR(
+    const signedTx = import_stellar_sdk12.TransactionBuilder.fromXDR(
       signResult.signedTxXdr,
       stellarConfig.networkPassphrase
     );
@@ -2959,7 +3140,7 @@ var RelayerExecutionStrategy = class {
       throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
     }
     const allowHttp = new URL(rpcUrl).hostname === "localhost";
-    return new import_stellar_sdk10.rpc.Server(rpcUrl, { allowHttp });
+    return new import_stellar_sdk12.rpc.Server(rpcUrl, { allowHttp });
   }
   getConnectedWalletAddress() {
     const connectionStatus = getStellarWalletConnectionStatus();
@@ -3090,10 +3271,10 @@ var RelayerExecutionStrategy = class {
 };
 
 // src/configuration/execution.ts
-var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG7 = "adapter-stellar-execution-config";
 async function getStellarSupportedExecutionMethods() {
-  import_ui_builder_utils19.logger.warn(
+  import_ui_builder_utils23.logger.warn(
     "adapter-stellar-execution-config",
     "getStellarSupportedExecutionMethods is using placeholder implementation."
   );
@@ -3119,11 +3300,11 @@ async function getStellarSupportedExecutionMethods() {
   ]);
 }
 async function _validateMultisigConfig(_config, _walletStatus) {
-  import_ui_builder_utils19.logger.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
+  import_ui_builder_utils23.logger.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
   return true;
 }
 async function validateStellarExecutionConfig(config, walletStatus) {
-  import_ui_builder_utils19.logger.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
+  import_ui_builder_utils23.logger.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
   switch (config.method) {
     case "eoa":
       return validateEoaConfig(config, walletStatus);
@@ -3133,7 +3314,7 @@ async function validateStellarExecutionConfig(config, walletStatus) {
       return _validateMultisigConfig(config, walletStatus);
     default: {
       const unknownMethod = config.method;
-      import_ui_builder_utils19.logger.warn(
+      import_ui_builder_utils23.logger.warn(
         SYSTEM_LOG_TAG7,
         `Unsupported execution method type encountered: ${unknownMethod}`
       );
@@ -3143,16 +3324,16 @@ async function validateStellarExecutionConfig(config, walletStatus) {
 }
 
 // src/configuration/rpc.ts
-var import_ui_builder_utils20 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
 function validateStellarRpcEndpoint(rpcConfig) {
   try {
-    if (!(0, import_ui_builder_utils20.isValidUrl)(rpcConfig.url)) {
-      import_ui_builder_utils20.logger.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
+    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_utils20.logger.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
+    import_ui_builder_utils24.logger.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
     return false;
   }
 }
@@ -3200,7 +3381,7 @@ async function testStellarRpcConnection(rpcConfig, timeoutMs = 5e3) {
     }
     return { success: true, latency };
   } catch (error) {
-    import_ui_builder_utils20.logger.error("testStellarRpcConnection", "Connection test failed:", error);
+    import_ui_builder_utils24.logger.error("testStellarRpcConnection", "Connection test failed:", error);
     if (error instanceof Error && error.name === "AbortError") {
       return {
         success: false,
@@ -3419,11 +3600,11 @@ function getStellarCompatibleFieldTypes(parameterType) {
 
 // src/mapping/field-generator.ts
 var import_lodash = require("lodash");
-var import_ui_builder_utils22 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils26 = require("@openzeppelin/ui-builder-utils");
 
 // src/mapping/enum-metadata.ts
-var import_stellar_sdk11 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils21 = require("@openzeppelin/ui-builder-utils");
+var import_stellar_sdk13 = require("@stellar/stellar-sdk");
+var import_ui_builder_utils25 = require("@openzeppelin/ui-builder-utils");
 function extractEnumVariants(entries, enumName) {
   try {
     const entry = entries.find((e) => {
@@ -3437,20 +3618,20 @@ function extractEnumVariants(entries, enumName) {
       return null;
     }
     const entryKind = entry.switch();
-    if (entryKind.value === import_stellar_sdk11.xdr.ScSpecEntryKind.scSpecEntryUdtUnionV0().value) {
+    if (entryKind.value === import_stellar_sdk13.xdr.ScSpecEntryKind.scSpecEntryUdtUnionV0().value) {
       const unionUdt = entry.udtUnionV0();
       const cases = unionUdt.cases();
       const variants = [];
       let isUnitOnly = true;
       for (const caseEntry of cases) {
         const caseKind = caseEntry.switch();
-        if (caseKind.value === import_stellar_sdk11.xdr.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseVoidV0().value) {
+        if (caseKind.value === import_stellar_sdk13.xdr.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseVoidV0().value) {
           const voidCase = caseEntry.voidCase();
           variants.push({
             name: voidCase.name().toString(),
             type: "void"
           });
-        } else if (caseKind.value === import_stellar_sdk11.xdr.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseTupleV0().value) {
+        } else if (caseKind.value === import_stellar_sdk13.xdr.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseTupleV0().value) {
           const tupleCase = caseEntry.tupleCase();
           const payloadTypes = tupleCase.type().map((typeDef) => extractSorobanTypeFromScSpec(typeDef));
           variants.push({
@@ -3467,7 +3648,7 @@ function extractEnumVariants(entries, enumName) {
         isUnitOnly
       };
     }
-    if (entryKind.value === import_stellar_sdk11.xdr.ScSpecEntryKind.scSpecEntryUdtEnumV0().value) {
+    if (entryKind.value === import_stellar_sdk13.xdr.ScSpecEntryKind.scSpecEntryUdtEnumV0().value) {
       const enumUdt = entry.udtEnumV0();
       const cases = enumUdt.cases();
       const variants = [];
@@ -3487,7 +3668,7 @@ function extractEnumVariants(entries, enumName) {
     }
     return null;
   } catch (error) {
-    import_ui_builder_utils21.logger.error("extractEnumVariants", `Failed to extract enum variants for ${enumName}:`, error);
+    import_ui_builder_utils25.logger.error("extractEnumVariants", `Failed to extract enum variants for ${enumName}:`, error);
     return null;
   }
 }
@@ -3505,10 +3686,10 @@ function isEnumType(entries, typeName) {
       return false;
     }
     const entryKind = entry.switch();
-    const isEnum = entryKind.value === import_stellar_sdk11.xdr.ScSpecEntryKind.scSpecEntryUdtUnionV0().value || entryKind.value === import_stellar_sdk11.xdr.ScSpecEntryKind.scSpecEntryUdtEnumV0().value;
+    const isEnum = entryKind.value === import_stellar_sdk13.xdr.ScSpecEntryKind.scSpecEntryUdtUnionV0().value || entryKind.value === import_stellar_sdk13.xdr.ScSpecEntryKind.scSpecEntryUdtEnumV0().value;
     return isEnum;
   } catch (error) {
-    import_ui_builder_utils21.logger.error("isEnumType", `Failed to check if ${typeName} is enum:`, error);
+    import_ui_builder_utils25.logger.error("isEnumType", `Failed to check if ${typeName} is enum:`, error);
     return false;
   }
 }
@@ -3521,12 +3702,13 @@ function generateStellarDefaultField(parameter, contractSchema) {
   const specEntries = contractSchema?.metadata?.specEntries;
   const fieldType = mapStellarParameterTypeToFieldType(parameter.type);
   if (parameter.type === "unknown") {
-    import_ui_builder_utils22.logger.warn(
+    import_ui_builder_utils26.logger.warn(
       "adapter-stellar",
       `[generateStellarDefaultField] Parameter "${parameter.name}" has type "unknown"`
     );
   }
   let enumMetadata = null;
+  let structComponents = null;
   let finalFieldType = fieldType;
   let options;
   if (isLikelyEnumType(parameter.type)) {
@@ -3553,6 +3735,12 @@ function generateStellarDefaultField(parameter, contractSchema) {
       };
     }
   }
+  if (specEntries && isStructType(specEntries, parameter.type)) {
+    const structFields = extractStructFields(specEntries, parameter.type);
+    if (structFields && structFields.length > 0) {
+      structComponents = structFields;
+    }
+  }
   const baseField = {
     id: `field-${Math.random().toString(36).substring(2, 9)}`,
     name: parameter.name || parameter.type,
@@ -3561,7 +3749,7 @@ function generateStellarDefaultField(parameter, contractSchema) {
     type: finalFieldType,
     placeholder: enumMetadata ? `Select ${parameter.displayName || parameter.name || parameter.type}` : `Enter ${parameter.displayName || parameter.name || parameter.type}`,
     helperText: parameter.description || "",
-    defaultValue: (0, import_ui_builder_utils22.getDefaultValueForType)(finalFieldType),
+    defaultValue: (0, import_ui_builder_utils26.getDefaultValueForType)(finalFieldType),
     validation: getDefaultValidationForType(),
     width: "full",
     options
@@ -3624,12 +3812,15 @@ function generateStellarDefaultField(parameter, contractSchema) {
       return mapField;
     }
   }
-  if (parameter.components && (fieldType === "object" || fieldType === "array-object")) {
-    const result = {
-      ...baseField,
-      components: parameter.components
-    };
-    return result;
+  if (fieldType === "object" || fieldType === "array-object") {
+    const componentsToUse = parameter.components || structComponents;
+    if (componentsToUse) {
+      const result = {
+        ...baseField,
+        components: componentsToUse
+      };
+      return result;
+    }
   }
   if (enumMetadata) {
     const result = {
@@ -3642,11 +3833,11 @@ function generateStellarDefaultField(parameter, contractSchema) {
 }
 
 // src/transaction/formatter.ts
-var import_stellar_sdk12 = require("@stellar/stellar-sdk");
+var import_stellar_sdk14 = require("@stellar/stellar-sdk");
 var import_ui_builder_types4 = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils27 = require("@openzeppelin/ui-builder-utils");
 function formatStellarTransactionData(contractSchema, functionId, submittedInputs, fields) {
-  import_ui_builder_utils23.logger.info(
+  import_ui_builder_utils27.logger.info(
     "formatStellarTransactionData",
     `Formatting Stellar transaction data for function: ${functionId}`
   );
@@ -3664,7 +3855,7 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
     let value;
     if (fieldConfig.isHardcoded) {
       if (fieldConfig.hardcodedValue === void 0 && fieldConfig.name in submittedInputs) {
-        import_ui_builder_utils23.logger.warn(
+        import_ui_builder_utils27.logger.warn(
           "formatStellarTransactionData",
           `Field '${fieldConfig.name}' is hardcoded with undefined value but has submitted input. Using submitted input instead.`
         );
@@ -3719,7 +3910,7 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
     throw new Error("Contract address is missing or invalid in the provided schema.");
   }
   try {
-    import_stellar_sdk12.Address.fromString(contractSchema.address);
+    import_stellar_sdk14.Address.fromString(contractSchema.address);
   } catch {
     throw new Error("Contract address is missing or invalid in the provided schema.");
   }
@@ -3736,7 +3927,7 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
       // For example: fee, timeout, memo, etc.
     }
   };
-  import_ui_builder_utils23.logger.debug(
+  import_ui_builder_utils27.logger.debug(
     "formatStellarTransactionData",
     "Formatted transaction data:",
     stellarTransactionData
@@ -3745,27 +3936,27 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
 }
 
 // src/transaction/sender.ts
-var import_stellar_sdk14 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils25 = require("@openzeppelin/ui-builder-utils");
+var import_stellar_sdk16 = require("@stellar/stellar-sdk");
+var import_ui_builder_utils29 = require("@openzeppelin/ui-builder-utils");
 
 // src/transaction/eoa.ts
-var import_stellar_sdk13 = require("@stellar/stellar-sdk");
-var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
+var import_stellar_sdk15 = require("@stellar/stellar-sdk");
+var import_ui_builder_utils28 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG8 = "EoaExecutionStrategy";
-function getSorobanRpcServer2(networkConfig) {
-  const customRpcConfig = import_ui_builder_utils24.userRpcConfigService.getUserRpcConfig(networkConfig.id);
+function getSorobanRpcServer3(networkConfig) {
+  const customRpcConfig = import_ui_builder_utils28.userRpcConfigService.getUserRpcConfig(networkConfig.id);
   const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
   if (!rpcUrl) {
     throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
   }
   const allowHttp = new URL(rpcUrl).hostname === "localhost";
-  return new import_stellar_sdk13.rpc.Server(rpcUrl, {
+  return new import_stellar_sdk15.rpc.Server(rpcUrl, {
     allowHttp
   });
 }
 var EoaExecutionStrategy = class {
   async execute(transactionData, executionConfig, networkConfig, onStatusChange, _runtimeApiKey) {
-    import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG8, "Using Stellar EOA execution strategy");
+    import_ui_builder_utils28.logger.info(SYSTEM_LOG_TAG8, "Using Stellar EOA execution strategy");
     if (executionConfig.method !== "eoa") {
       throw new Error(`Expected EOA execution config, got: ${executionConfig.method}`);
     }
@@ -3773,19 +3964,19 @@ var EoaExecutionStrategy = class {
   }
   async executeEoaTransaction(txData, stellarConfig, onStatusChange) {
     try {
-      const rpcServer = getSorobanRpcServer2(stellarConfig);
+      const rpcServer = getSorobanRpcServer3(stellarConfig);
       const connectedAddress = this.getConnectedWalletAddress();
-      import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG8, `Connected address: ${connectedAddress}`);
+      import_ui_builder_utils28.logger.info(SYSTEM_LOG_TAG8, `Connected address: ${connectedAddress}`);
       let sourceAccount;
       try {
         const accountResponse = await rpcServer.getAccount(connectedAddress);
-        sourceAccount = new import_stellar_sdk13.Account(connectedAddress, accountResponse.sequenceNumber());
+        sourceAccount = new import_stellar_sdk15.Account(connectedAddress, accountResponse.sequenceNumber());
       } catch (error) {
         throw new Error(`Failed to load account details: ${error.message}`);
       }
-      const contract2 = new import_stellar_sdk13.Contract(txData.contractAddress);
-      const transactionBuilder = new import_stellar_sdk13.TransactionBuilder(sourceAccount, {
-        fee: import_stellar_sdk13.BASE_FEE,
+      const contract2 = new import_stellar_sdk15.Contract(txData.contractAddress);
+      const transactionBuilder = new import_stellar_sdk15.TransactionBuilder(sourceAccount, {
+        fee: import_stellar_sdk15.BASE_FEE,
         networkPassphrase: stellarConfig.networkPassphrase
       });
       const scValArgs = txData.args.map((arg, index) => {
@@ -3798,7 +3989,7 @@ var EoaExecutionStrategy = class {
       let transaction = transactionBuilder.build();
       try {
         const simulation = await rpcServer.simulateTransaction(transaction);
-        if (import_stellar_sdk13.rpc.Api.isSimulationError(simulation)) {
+        if (import_stellar_sdk15.rpc.Api.isSimulationError(simulation)) {
           throw new Error(`Transaction simulation failed: ${simulation.error}`);
         }
         transaction = await rpcServer.prepareTransaction(transaction);
@@ -3808,7 +3999,7 @@ var EoaExecutionStrategy = class {
       onStatusChange("pendingSignature", {});
       try {
         const signResult = await signTransaction(transaction.toXDR(), connectedAddress);
-        const signedTx = import_stellar_sdk13.TransactionBuilder.fromXDR(
+        const signedTx = import_stellar_sdk15.TransactionBuilder.fromXDR(
           signResult.signedTxXdr,
           stellarConfig.networkPassphrase
         );
@@ -3834,7 +4025,7 @@ var EoaExecutionStrategy = class {
         throw new Error(`Transaction failed to submit: ${sendResult.status}`);
       }
       const txHash = sendResult.hash;
-      import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG8, `Transaction submitted successfully: ${txHash}`);
+      import_ui_builder_utils28.logger.info(SYSTEM_LOG_TAG8, `Transaction submitted successfully: ${txHash}`);
       try {
         let txResponse;
         const MAX_ATTEMPTS = 10;
@@ -3853,10 +4044,10 @@ var EoaExecutionStrategy = class {
           }
         }
         if (attempts >= MAX_ATTEMPTS || txResponse?.status !== "SUCCESS") {
-          import_ui_builder_utils24.logger.warn(SYSTEM_LOG_TAG8, `Transaction confirmation timeout for ${txHash}`);
+          import_ui_builder_utils28.logger.warn(SYSTEM_LOG_TAG8, `Transaction confirmation timeout for ${txHash}`);
         }
       } catch (confirmError) {
-        import_ui_builder_utils24.logger.error(SYSTEM_LOG_TAG8, "Error waiting for confirmation:", confirmError);
+        import_ui_builder_utils28.logger.error(SYSTEM_LOG_TAG8, "Error waiting for confirmation:", confirmError);
       }
       onStatusChange("success", {
         txHash
@@ -3864,7 +4055,7 @@ var EoaExecutionStrategy = class {
       return { txHash };
     } catch (error) {
       const errorMessage = `Failed to execute Stellar EOA transaction: ${error.message}`;
-      import_ui_builder_utils24.logger.error(SYSTEM_LOG_TAG8, errorMessage, error);
+      import_ui_builder_utils28.logger.error(SYSTEM_LOG_TAG8, errorMessage, error);
       onStatusChange("error", {});
       throw new Error(errorMessage);
     }
@@ -3881,7 +4072,7 @@ var EoaExecutionStrategy = class {
 // src/transaction/sender.ts
 var SYSTEM_LOG_TAG9 = "adapter-stellar";
 async function signAndBroadcastStellarTransaction(transactionData, executionConfig, networkConfig, onStatusChange, runtimeApiKey) {
-  import_ui_builder_utils25.logger.info(
+  import_ui_builder_utils29.logger.info(
     SYSTEM_LOG_TAG9,
     "Stellar signAndBroadcast called with executionConfig:",
     executionConfig
@@ -3902,7 +4093,7 @@ async function signAndBroadcastStellarTransaction(transactionData, executionConf
       throw new Error("Multisig execution method not yet implemented for Stellar.");
     default: {
       const exhaustiveCheck = executionConfig;
-      import_ui_builder_utils25.logger.error(SYSTEM_LOG_TAG9, `Unsupported execution method encountered: ${exhaustiveCheck}`);
+      import_ui_builder_utils29.logger.error(SYSTEM_LOG_TAG9, `Unsupported execution method encountered: ${exhaustiveCheck}`);
       throw new Error(`Unsupported execution method: ${exhaustiveCheck}`);
     }
   }
@@ -3918,7 +4109,7 @@ async function signAndBroadcastStellarTransaction(transactionData, executionConf
 
 // src/wallet/components/StellarWalletUiRoot.tsx
 var import_react5 = require("react");
-var import_ui_builder_utils26 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils30 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/context/StellarWalletContext.ts
 var import_react4 = require("react");
@@ -3937,9 +4128,9 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
     const currentState = stellarUiKitManager.getState();
     if (uiKitConfig || !currentState.currentFullUiKitConfig) {
       const configToUse = uiKitConfig || { kitName: "custom", kitConfig: {} };
-      import_ui_builder_utils26.logger.debug("StellarWalletUiRoot", "Configuring UI kit with:", configToUse);
+      import_ui_builder_utils30.logger.debug("StellarWalletUiRoot", "Configuring UI kit with:", configToUse);
       stellarUiKitManager.configure(configToUse).catch((error) => {
-        import_ui_builder_utils26.logger.error("Failed to configure Stellar UI kit:", error);
+        import_ui_builder_utils30.logger.error("Failed to configure Stellar UI kit:", error);
       });
     }
   }, [uiKitConfig]);
@@ -3953,7 +4144,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
     const unsubscribeFromConnectionChanges = onStellarWalletConnectionChange(
       (currentStatus, _previousStatus) => {
         setAddress(currentStatus.address || null);
-        import_ui_builder_utils26.logger.debug(
+        import_ui_builder_utils30.logger.debug(
           "StellarWalletUiRoot",
           `Connection status changed: ${currentStatus.isConnected ? "connected" : "disconnected"}`,
           currentStatus.address
@@ -3972,7 +4163,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         const connectors = await getStellarAvailableConnectors();
         setAvailableWallets(connectors);
       } catch (error) {
-        import_ui_builder_utils26.logger.error("Failed to load available wallets:", String(error));
+        import_ui_builder_utils30.logger.error("Failed to load available wallets:", String(error));
       }
     };
     if (!uiKitManagerState.isInitializing && uiKitManagerState.stellarKitProvider) {
@@ -3989,7 +4180,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         throw new Error(result.error || "Failed to connect wallet");
       }
     } catch (error) {
-      import_ui_builder_utils26.logger.error("Failed to connect:", String(error));
+      import_ui_builder_utils30.logger.error("Failed to connect:", String(error));
       throw error;
     } finally {
       setIsConnecting(false);
@@ -4004,7 +4195,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         throw new Error(result.error || "Failed to disconnect wallet");
       }
     } catch (error) {
-      import_ui_builder_utils26.logger.error("Failed to disconnect:", String(error));
+      import_ui_builder_utils30.logger.error("Failed to disconnect:", String(error));
       throw error;
     }
   }, []);
@@ -4123,20 +4314,20 @@ var stellarFacadeHooks = {
 };
 
 // src/wallet/hooks/useUiKitConfig.ts
-var import_ui_builder_utils27 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils31 = require("@openzeppelin/ui-builder-utils");
 var defaultConfig = {
   kitName: "custom",
   // Default to using our custom implementation for Stellar
   kitConfig: {}
 };
 function loadInitialConfigFromAppService() {
-  import_ui_builder_utils27.logger.debug(
+  import_ui_builder_utils31.logger.debug(
     "stellar:useUiKitConfig",
     "Attempting to load initial config from AppConfigService..."
   );
-  const configObj = import_ui_builder_utils27.appConfigService.getWalletUIConfig("stellar");
+  const configObj = import_ui_builder_utils31.appConfigService.getWalletUIConfig("stellar");
   if (configObj && configObj.kitName) {
-    import_ui_builder_utils27.logger.info(
+    import_ui_builder_utils31.logger.info(
       "stellar:useUiKitConfig",
       `Loaded initial config from AppConfigService: kitName=${configObj.kitName}`,
       configObj.kitConfig
@@ -4146,7 +4337,7 @@ function loadInitialConfigFromAppService() {
       kitConfig: { ...defaultConfig.kitConfig, ...configObj.kitConfig || {} }
     };
   }
-  import_ui_builder_utils27.logger.debug(
+  import_ui_builder_utils31.logger.debug(
     "stellar:useUiKitConfig",
     "No initial config found in AppConfigService, using module default."
   );
@@ -4157,12 +4348,12 @@ function loadInitialConfigFromAppService() {
 var import_lucide_react2 = require("lucide-react");
 var import_react10 = require("react");
 var import_ui_builder_ui6 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils29 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils33 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/components/connect/ConnectorDialog.tsx
 var import_react9 = require("react");
 var import_ui_builder_ui5 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils28 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils32 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var ConnectorDialog = ({ open, onOpenChange }) => {
   const { connect } = useStellarConnect();
@@ -4177,7 +4368,7 @@ var ConnectorDialog = ({ open, onOpenChange }) => {
         const availableConnectors = await getStellarAvailableConnectors();
         setConnectors(availableConnectors);
       } catch (err) {
-        import_ui_builder_utils28.logger.error("Failed to load Stellar connectors:", String(err));
+        import_ui_builder_utils32.logger.error("Failed to load Stellar connectors:", String(err));
         setError("Failed to load available wallets");
       } finally {
         setLoadingConnectors(false);
@@ -4268,7 +4459,7 @@ var CustomConnectButton = ({
     return null;
   }
   const showButtonLoading = isConnecting || isManuallyInitiated;
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: (0, import_ui_builder_utils29.cn)("flex items-center", className), children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: (0, import_ui_builder_utils33.cn)("flex items-center", className), children: [
     /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
       import_ui_builder_ui6.Button,
       {
@@ -4302,7 +4493,7 @@ var CustomConnectButton = ({
 // src/wallet/components/account/AccountDisplay.tsx
 var import_lucide_react3 = require("lucide-react");
 var import_ui_builder_ui7 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils30 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils34 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime9 = require("react/jsx-runtime");
 var CustomAccountDisplay = ({ className }) => {
   const { isConnected, address } = useStellarAccount();
@@ -4310,9 +4501,9 @@ var CustomAccountDisplay = ({ className }) => {
   if (!isConnected || !address || !disconnect) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: (0, import_ui_builder_utils30.cn)("flex items-center gap-2", className), children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: (0, import_ui_builder_utils34.cn)("flex items-center gap-2", className), children: [
     /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "flex flex-col", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "text-xs font-medium", children: (0, import_ui_builder_utils30.truncateMiddle)(address, 4, 4) }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "text-xs font-medium", children: (0, import_ui_builder_utils34.truncateMiddle)(address, 4, 4) }),
       /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "text-[9px] text-muted-foreground -mt-0.5", children: "Stellar Account" })
     ] }),
     /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
@@ -4331,18 +4522,18 @@ var CustomAccountDisplay = ({ className }) => {
 
 // src/wallet/utils/filterWalletComponents.ts
 var import_ui_builder_types5 = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils31 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils35 = require("@openzeppelin/ui-builder-utils");
 function filterWalletComponents(allPossibleComponents, exclusions, kitName = "custom") {
-  import_ui_builder_utils31.logger.debug(
+  import_ui_builder_utils35.logger.debug(
     "filterWalletComponents",
     `Filtering components for kit: ${kitName}. Exclusions: ${exclusions.join(", ")}.`
   );
   if (!allPossibleComponents || Object.keys(allPossibleComponents).length === 0) {
-    import_ui_builder_utils31.logger.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
+    import_ui_builder_utils35.logger.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
     return void 0;
   }
   if (exclusions.length === 0) {
-    import_ui_builder_utils31.logger.debug(
+    import_ui_builder_utils35.logger.debug(
       "filterWalletComponents",
       `Providing all components for kit: ${kitName}.`,
       allPossibleComponents
@@ -4361,14 +4552,14 @@ function filterWalletComponents(allPossibleComponents, exclusions, kitName = "cu
     }
   }
   if (componentCount > 0) {
-    import_ui_builder_utils31.logger.debug(
+    import_ui_builder_utils35.logger.debug(
       "filterWalletComponents",
       `Providing filtered components for kit: ${kitName} after exclusions (${exclusions.join(", ")}).`,
       filteredComponents
     );
     return filteredComponents;
   }
-  import_ui_builder_utils31.logger.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
+  import_ui_builder_utils35.logger.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
   return void 0;
 }
 function getComponentExclusionsFromConfig(kitConfig) {
@@ -4384,23 +4575,23 @@ function getComponentExclusionsFromConfig(kitConfig) {
 }
 
 // src/wallet/utils/uiKitService.ts
-var import_ui_builder_utils32 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils36 = require("@openzeppelin/ui-builder-utils");
 function getResolvedWalletComponents(uiKitConfiguration) {
-  import_ui_builder_utils32.logger.debug(
+  import_ui_builder_utils36.logger.debug(
     "stellar:uiKitService:getResolvedWalletComponents",
     "Received uiKitConfiguration:",
     JSON.stringify(uiKitConfiguration)
   );
   const currentKitName = uiKitConfiguration.kitName || "custom";
   if (currentKitName === "none") {
-    import_ui_builder_utils32.logger.info(
+    import_ui_builder_utils36.logger.info(
       "stellar:uiKitService",
       'UI Kit set to "none" for getResolvedWalletComponents, not providing wallet components.'
     );
     return void 0;
   }
   const exclusions = getComponentExclusionsFromConfig(uiKitConfiguration.kitConfig);
-  import_ui_builder_utils32.logger.debug(
+  import_ui_builder_utils36.logger.debug(
     "stellar:uiKitService",
     `Extracted component exclusions for ${currentKitName}: ${exclusions.join(", ") || "none"}.`
   );
@@ -4410,7 +4601,7 @@ function getResolvedWalletComponents(uiKitConfiguration) {
       AccountDisplay: CustomAccountDisplay
       // NetworkSwitcher is not included as Stellar doesn't support network switching
     };
-    import_ui_builder_utils32.logger.info(
+    import_ui_builder_utils36.logger.info(
       "stellar:uiKitService",
       `Providing custom Stellar wallet components for kit: ${currentKitName}`
     );
@@ -4422,10 +4613,10 @@ function getResolvedWalletComponents(uiKitConfiguration) {
       // The kit's native button handles account display internally
       AccountDisplay: void 0
     };
-    import_ui_builder_utils32.logger.info("stellar:uiKitService", "Using Stellar Wallets Kit native button");
+    import_ui_builder_utils36.logger.info("stellar:uiKitService", "Using Stellar Wallets Kit native button");
     return stellarKitComponents;
   }
-  import_ui_builder_utils32.logger.warn(
+  import_ui_builder_utils36.logger.warn(
     "stellar:uiKitService",
     `UI Kit "${currentKitName}" for getResolvedWalletComponents not explicitly supported. No components provided.`
   );
@@ -4433,9 +4624,9 @@ function getResolvedWalletComponents(uiKitConfiguration) {
 }
 
 // src/wallet/services/configResolutionService.ts
-var import_ui_builder_utils33 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils37 = require("@openzeppelin/ui-builder-utils");
 async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppServiceKitName, currentAppServiceConfig, options) {
-  import_ui_builder_utils33.logger.debug(
+  import_ui_builder_utils37.logger.debug(
     "stellar:configResolutionService:resolveFullUiKitConfiguration",
     "Starting resolution with:",
     {
@@ -4446,7 +4637,7 @@ async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppSe
     }
   );
   if (options?.loadUiKitNativeConfig) {
-    import_ui_builder_utils33.logger.debug(
+    import_ui_builder_utils37.logger.debug(
       "stellar:configResolutionService",
       "Native config loader provided but not currently supported for Stellar adapter"
     );
@@ -4459,7 +4650,7 @@ async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppSe
       ...programmaticOverrides.kitConfig || {}
     }
   };
-  import_ui_builder_utils33.logger.debug(
+  import_ui_builder_utils37.logger.debug(
     "stellar:configResolutionService:resolveFullUiKitConfiguration",
     "Resolved finalFullConfig:",
     finalFullConfig
@@ -4478,7 +4669,7 @@ var StellarAdapter = class {
     this.networkConfig = networkConfig;
     stellarUiKitManager.setNetworkConfig(networkConfig);
     getStellarWalletImplementation(networkConfig).catch((error) => {
-      import_ui_builder_utils34.logger.error(
+      import_ui_builder_utils38.logger.error(
         "StellarAdapter:constructor",
         "Failed to initialize wallet implementation:",
         error
@@ -4486,12 +4677,12 @@ var StellarAdapter = class {
     });
     const initialGlobalConfig = loadInitialConfigFromAppService();
     this.initialAppServiceKitName = initialGlobalConfig.kitName || "custom";
-    import_ui_builder_utils34.logger.info(
+    import_ui_builder_utils38.logger.info(
       "StellarAdapter:constructor",
       "Initial kitName from AppConfigService noted:",
       this.initialAppServiceKitName
     );
-    import_ui_builder_utils34.logger.info(
+    import_ui_builder_utils38.logger.info(
       "StellarAdapter",
       `Adapter initialized for network: ${networkConfig.name} (ID: ${networkConfig.id})`
     );
@@ -4638,7 +4829,7 @@ var StellarAdapter = class {
   onWalletConnectionChange(callback) {
     const walletImplementation = getInitializedStellarWalletImplementation();
     if (!walletImplementation) {
-      import_ui_builder_utils34.logger.warn(
+      import_ui_builder_utils38.logger.warn(
         "StellarAdapter:onWalletConnectionChange",
         "Wallet implementation not ready. Subscription may not work."
       );
@@ -4700,7 +4891,7 @@ var StellarAdapter = class {
       options
     );
     await stellarUiKitManager.configure(finalFullConfig);
-    import_ui_builder_utils34.logger.info(
+    import_ui_builder_utils38.logger.info(
       "StellarAdapter:configureUiKit",
       "StellarUiKitManager configuration requested with final config:",
       finalFullConfig
@@ -4721,7 +4912,7 @@ var StellarAdapter = class {
   getEcosystemWalletComponents() {
     const currentManagerState = stellarUiKitManager.getState();
     if (!currentManagerState.currentFullUiKitConfig) {
-      import_ui_builder_utils34.logger.debug(
+      import_ui_builder_utils38.logger.debug(
         "StellarAdapter:getEcosystemWalletComponents",
         "No UI kit configuration available in manager yet. Returning undefined components."
       );
@@ -4734,7 +4925,7 @@ var StellarAdapter = class {
    * @inheritdoc
    */
   getEcosystemReactUiContextProvider() {
-    import_ui_builder_utils34.logger.info(
+    import_ui_builder_utils38.logger.info(
       "StellarAdapter:getEcosystemReactUiContextProvider",
       "Returning StellarWalletUiRoot."
     );
@@ -4751,7 +4942,7 @@ var StellarAdapter = class {
     try {
       return await relayerStrategy.getStellarRelayers(serviceUrl, accessToken, this.networkConfig);
     } catch (error) {
-      import_ui_builder_utils34.logger.error("StellarAdapter", "Failed to fetch Stellar relayers:", error);
+      import_ui_builder_utils38.logger.error("StellarAdapter", "Failed to fetch Stellar relayers:", error);
       return Promise.resolve([]);
     }
   }
@@ -4765,7 +4956,7 @@ var StellarAdapter = class {
         this.networkConfig
       );
     } catch (error) {
-      import_ui_builder_utils34.logger.error("StellarAdapter", "Failed to fetch Stellar relayer details:", error);
+      import_ui_builder_utils38.logger.error("StellarAdapter", "Failed to fetch Stellar relayer details:", error);
       return Promise.resolve({});
     }
   }
@@ -4815,6 +5006,7 @@ var StellarAdapter = class {
 };
 
 // src/networks/mainnet.ts
+var import_react11 = require("@web3icons/react");
 var stellarPublic = {
   id: "stellar-public",
   exportConstName: "stellarPublic",
@@ -4827,10 +5019,11 @@ var stellarPublic = {
   sorobanRpcUrl: "https://mainnet.sorobanrpc.com",
   networkPassphrase: "Public Global Stellar Network ; September 2015",
   explorerUrl: "https://stellar.expert/explorer/public",
-  icon: "stellar"
+  iconComponent: import_react11.NetworkStellar
 };
 
 // src/networks/testnet.ts
+var import_react12 = require("@web3icons/react");
 var stellarTestnet = {
   id: "stellar-testnet",
   exportConstName: "stellarTestnet",
@@ -4843,7 +5036,7 @@ var stellarTestnet = {
   sorobanRpcUrl: "https://soroban-testnet.stellar.org",
   networkPassphrase: "Test SDF Network ; September 2015",
   explorerUrl: "https://stellar.expert/explorer/testnet",
-  icon: "stellar"
+  iconComponent: import_react12.NetworkStellar
 };
 
 // src/networks/index.ts
@@ -4865,6 +5058,10 @@ var stellarAdapterConfig = {
     runtime: {
       // Core Stellar libraries
       "@stellar/stellar-sdk": "^14.1.1",
+      // SAC (Stellar Asset Contract) support - dynamically loaded from CDN
+      // These are needed for XDR encoding when working with SAC contracts
+      "@stellar/stellar-xdr-json": "^23.0.0",
+      "lossless-json": "^4.0.2",
       // Wallet connection and integration
       "@creit.tech/stellar-wallets-kit": "^1.9.5",
       // OpenZeppelin Relayer integration (optional, for gasless transactions)