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

package/dist/index.js

@@ -4,11 +4,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 
 // src/adapter.ts
 import { isStellarNetworkConfig } from "@openzeppelin/ui-builder-types";
-import { logger as logger31 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger35 } from "@openzeppelin/ui-builder-utils";
 
 // src/contract/loader.ts
 import * as StellarSdk2 from "@stellar/stellar-sdk";
-import { logger as logger11 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger15 } from "@openzeppelin/ui-builder-utils";
 
 // src/validation/address.ts
 import { StrKey } from "@stellar/stellar-sdk";
@@ -1461,9 +1461,163 @@ async function queryStellarViewFunction(contractAddress, functionId, networkConf
   }
 }
 
+// src/sac/spec-cache.ts
+import { logger as logger13 } from "@openzeppelin/ui-builder-utils";
+
+// src/sac/spec-source.ts
+import { logger as logger11 } from "@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) {
+    logger11.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
+import { xdr as xdr8 } from "@stellar/stellar-sdk";
+import { parse, stringify } from "lossless-json";
+import stellarXdrJsonPackage from "@stellar/stellar-xdr-json/package.json";
+import { logger as logger12 } from "@openzeppelin/ui-builder-utils";
+var stellarXdrJsonVersion = stellarXdrJsonPackage.version ?? "23.0.0";
+var CDN_WASM_URL = `https://unpkg.com/@stellar/stellar-xdr-json@${stellarXdrJsonVersion}/stellar_xdr_json_bg.wasm`;
+var initialized = false;
+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) {
+    logger12.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 = parse(jsonString);
+    const result = [];
+    for (const entry of jsonData) {
+      const stringified = 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) {
+    logger12.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) => xdr8.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) {
+    logger13.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);
+    logger13.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
+import { Contract as Contract2, rpc as StellarRpc2, xdr as xdr9 } from "@stellar/stellar-sdk";
+import { logger as logger14, userRpcConfigService as userRpcConfigService2 } from "@openzeppelin/ui-builder-utils";
+function getSorobanRpcServer2(networkConfig) {
+  const customRpcConfig = userRpcConfigService2.getUserRpcConfig(networkConfig.id);
+  const rpcUrl = customRpcConfig?.url || networkConfig.sorobanRpcUrl;
+  if (!rpcUrl) {
+    throw new Error(`No Soroban RPC URL available for network ${networkConfig.name}`);
+  }
+  const allowHttp = new URL(rpcUrl).hostname === "localhost";
+  return new StellarRpc2.Server(rpcUrl, { allowHttp });
+}
+async function getStellarContractType(contractId, networkConfig) {
+  try {
+    if (!contractId) {
+      return null;
+    }
+    const rpcServer = getSorobanRpcServer2(networkConfig);
+    const ledgerKey = new Contract2(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 = xdr9.ContractExecutableType.contractExecutableWasm().name;
+    const execStellarAssetType = xdr9.ContractExecutableType.contractExecutableStellarAsset().name;
+    const detected = executable.switch()?.name;
+    if (detected === execWasmType) return "contractExecutableWasm";
+    if (detected === execStellarAssetType) return "contractExecutableStellarAsset";
+    return null;
+  } catch (error) {
+    logger14.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) {
-  logger11.info("loadStellarContractFromAddress", "Loading contract:", {
+  logger15.info("loadStellarContractFromAddress", "Loading contract:", {
     contractAddress,
     network: networkConfig.name,
     rpcUrl: networkConfig.sorobanRpcUrl,
@@ -1473,6 +1627,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) {
+      logger15.warn(
+        "loadStellarContractFromAddress",
+        "SAC detection failed, falling back to regular client:",
+        e
+      );
+    }
     let contractClient;
     try {
       contractClient = await StellarSdk2.contract.Client.from({
@@ -1484,12 +1665,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.";
-        logger11.error("loadStellarContractFromAddress", friendly);
+        logger15.error("loadStellarContractFromAddress", friendly);
         throw new Error(`NO_WASM: ${friendly}`);
       }
       throw e;
     }
-    logger11.info("loadStellarContractFromAddress", "Contract client created successfully");
+    logger15.info("loadStellarContractFromAddress", "Contract client created successfully");
     let specEntries = [];
     try {
       if (contractClient.spec && typeof contractClient.spec === "object") {
@@ -1504,20 +1685,20 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            logger11.warn("loadStellarContractFromAddress", "entries() method failed:", e);
+            logger15.warn("loadStellarContractFromAddress", "entries() method failed:", e);
           }
         }
         if (specEntries.length === 0 && typeof spec.entries === "function") {
           try {
             specEntries = spec.entries();
           } catch (e) {
-            logger11.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
+            logger15.warn("loadStellarContractFromAddress", "direct entries() method failed:", e);
           }
         }
-        logger11.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
+        logger15.info("loadStellarContractFromAddress", `Found ${specEntries.length} spec entries`);
       }
     } catch (specError) {
-      logger11.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
+      logger15.warn("loadStellarContractFromAddress", "Could not extract spec entries:", specError);
     }
     const functions = await extractFunctionsFromSpec(
       contractClient.spec,
@@ -1525,7 +1706,7 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
       specEntries,
       networkConfig
     );
-    logger11.info(
+    logger15.info(
       "loadStellarContractFromAddress",
       `Successfully extracted ${functions.length} functions`
     );
@@ -1540,28 +1721,28 @@ async function loadStellarContractFromAddress(contractAddress, networkConfig) {
   } catch (error) {
     const msg = error?.message || String(error);
     if (msg.startsWith("NO_WASM:")) {
-      logger11.error("loadStellarContractFromAddress", msg);
+      logger15.error("loadStellarContractFromAddress", msg);
       throw new Error(msg);
     }
-    logger11.error("loadStellarContractFromAddress", "Failed to load contract:", error);
+    logger15.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();
-    logger11.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
+    logger15.info("extractFunctionsFromSpec", `Found ${specFunctions.length} functions in spec`);
     return await Promise.all(
       specFunctions.map(async (func, index) => {
         try {
           const functionName = func.name().toString();
-          logger11.info("extractFunctionsFromSpec", `Processing function: ${functionName}`);
+          logger15.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") {
-                logger11.warn(
+                logger15.warn(
                   "extractFunctionsFromSpec",
                   `Unknown type for parameter "${inputName}" in function "${functionName}"`
                 );
@@ -1571,12 +1752,12 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 const structFields = extractStructFields(specEntries, inputType);
                 if (structFields && structFields.length > 0) {
                   components = structFields;
-                  logger11.debug(
+                  logger15.debug(
                     "extractFunctionsFromSpec",
                     `Extracted ${structFields.length} fields for struct type "${inputType}": ${structFields.map((f) => `${f.name}:${f.type}`).join(", ")}`
                   );
                 } else {
-                  logger11.warn(
+                  logger15.warn(
                     "extractFunctionsFromSpec",
                     `No fields extracted for struct "${inputType}"`
                   );
@@ -1588,7 +1769,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 ...components && { components }
               };
             } catch (error) {
-              logger11.warn(
+              logger15.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse input ${inputIndex}:`,
                 error
@@ -1607,7 +1788,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 type: outputType
               };
             } catch (error) {
-              logger11.warn(
+              logger15.warn(
                 "extractFunctionsFromSpec",
                 `Failed to parse output ${outputIndex}:`,
                 error
@@ -1623,7 +1804,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
           if (networkConfig) {
             try {
               const inputTypes = inputs.map((input) => input.type);
-              logger11.debug(
+              logger15.debug(
                 "extractFunctionsFromSpec",
                 `Checking state mutability for ${functionName} with input types: ${inputTypes.join(", ")}`
               );
@@ -1634,20 +1815,20 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
                 inputTypes
               );
               stateMutability = modifiesState ? "nonpayable" : "view";
-              logger11.info(
+              logger15.info(
                 "extractFunctionsFromSpec",
                 `Function ${functionName} state mutability determined:`,
                 { modifiesState, stateMutability }
               );
             } catch (error) {
-              logger11.warn(
+              logger15.warn(
                 "extractFunctionsFromSpec",
                 `Failed to determine state mutability for ${functionName}, assuming it modifies state:`,
                 error
               );
             }
           } else {
-            logger11.warn(
+            logger15.warn(
               "extractFunctionsFromSpec",
               `No network config provided for ${functionName}, assuming it modifies state`
             );
@@ -1665,7 +1846,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
             stateMutability
           };
         } catch (error) {
-          logger11.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
+          logger15.error("extractFunctionsFromSpec", `Failed to process function ${index}:`, error);
           return {
             id: `function_${index}`,
             name: `function_${index}`,
@@ -1681,7 +1862,7 @@ async function extractFunctionsFromSpec(spec, contractAddress, specEntries, netw
       })
     );
   } catch (error) {
-    logger11.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
+    logger15.error("extractFunctionsFromSpec", "Failed to extract functions from spec:", error);
     throw new Error(`Failed to extract functions: ${error.message}`);
   }
 }
@@ -1981,21 +2162,21 @@ var StellarRelayerOptions = ({ options, onChange }) => {
 import {
   Account as Account2,
   BASE_FEE as BASE_FEE2,
-  Contract as Contract2,
-  rpc as StellarRpc2,
+  Contract as Contract3,
+  rpc as StellarRpc3,
   TransactionBuilder as TransactionBuilder2
 } from "@stellar/stellar-sdk";
 import {
   Configuration,
   RelayersApi
 } from "@openzeppelin/relayer-sdk";
-import { logger as logger17 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger21 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/connection.ts
-import { logger as logger16 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger20 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/utils/stellarWalletImplementationManager.ts
-import { appConfigService, logger as logger13 } from "@openzeppelin/ui-builder-utils";
+import { appConfigService, logger as logger17 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/implementation/wallets-kit-implementation.ts
 import {
@@ -2003,7 +2184,7 @@ import {
   StellarWalletsKit,
   WalletNetwork
 } from "@creit.tech/stellar-wallets-kit";
-import { logger as logger12 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger16 } from "@openzeppelin/ui-builder-utils";
 var LOG_SYSTEM = "StellarWalletImplementation";
 var WalletsKitImplementation = class {
   /**
@@ -2024,7 +2205,7 @@ var WalletsKitImplementation = class {
     __publicField(this, "currentWalletId", null);
     __publicField(this, "connectionStatusListeners", /* @__PURE__ */ new Set());
     this.networkConfig = networkConfig || null;
-    logger12.info(
+    logger16.info(
       LOG_SYSTEM,
       "Constructor called. Initial anticipated kitName:",
       initialUiKitConfig?.kitName,
@@ -2032,7 +2213,7 @@ var WalletsKitImplementation = class {
       networkConfig?.name
     );
     this.initialized = true;
-    logger12.info(
+    logger16.info(
       LOG_SYSTEM,
       "StellarWalletImplementation instance initialized (StellarWalletsKit config creation deferred)."
     );
@@ -2042,10 +2223,10 @@ var WalletsKitImplementation = class {
    * @param config - The Stellar network configuration
    */
   setNetworkConfig(config) {
-    logger12.info(LOG_SYSTEM, "Network config updated:", config.name);
+    logger16.info(LOG_SYSTEM, "Network config updated:", config.name);
     this.networkConfig = config;
     if (this.activeStellarKit || this.defaultInstanceKit) {
-      logger12.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
+      logger16.info(LOG_SYSTEM, "Active kits detected - may need reconfiguration for new network");
     }
   }
   /**
@@ -2055,14 +2236,14 @@ var WalletsKitImplementation = class {
    * @param kit - The StellarWalletsKit object to set as active, or null to clear it.
    */
   setActiveStellarKit(kit) {
-    logger12.info(
+    logger16.info(
       LOG_SYSTEM,
       "setActiveStellarKit called with kit:",
       kit ? "Valid StellarWalletsKit" : "Null"
     );
     this.activeStellarKit = kit;
     if (this.unsubscribeFromStatusChanges) {
-      logger12.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
+      logger16.info(LOG_SYSTEM, "Re-establishing connection status monitoring with new kit");
     }
   }
   /**
@@ -2071,14 +2252,14 @@ var WalletsKitImplementation = class {
    * @returns A default StellarWalletsKit instance
    */
   createDefaultKit() {
-    logger12.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
+    logger16.info(LOG_SYSTEM, "Creating default StellarWalletsKit instance");
     const network = this.getWalletNetwork();
     const kit = new StellarWalletsKit({
       network,
       selectedWalletId: void 0,
       modules: allowAllModules()
     });
-    logger12.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
+    logger16.info(LOG_SYSTEM, "Default StellarWalletsKit instance created");
     return kit;
   }
   /**
@@ -2086,7 +2267,7 @@ var WalletsKitImplementation = class {
    */
   getWalletNetwork() {
     if (!this.networkConfig) {
-      logger12.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
+      logger16.warn(LOG_SYSTEM, "No network config available, defaulting to TESTNET");
       return WalletNetwork.TESTNET;
     }
     return this.networkConfig.type === "mainnet" ? WalletNetwork.PUBLIC : WalletNetwork.TESTNET;
@@ -2104,7 +2285,7 @@ var WalletsKitImplementation = class {
    */
   async getAvailableConnectors() {
     if (!this.initialized) {
-      logger12.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
+      logger16.warn(LOG_SYSTEM, "getAvailableConnectors called before initialization");
       return [];
     }
     try {
@@ -2117,10 +2298,10 @@ var WalletsKitImplementation = class {
         installed: wallet.isAvailable,
         type: wallet.type || "browser"
       }));
-      logger12.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
+      logger16.info(LOG_SYSTEM, `Found ${connectors.length} available wallet connectors`);
       return connectors;
     } catch (error) {
-      logger12.error(LOG_SYSTEM, "Failed to get available connectors:", error);
+      logger16.error(LOG_SYSTEM, "Failed to get available connectors:", error);
       return [];
     }
   }
@@ -2136,7 +2317,7 @@ var WalletsKitImplementation = class {
     try {
       const prevStatus = this.getWalletConnectionStatus();
       const kit = this.getKitToUse();
-      logger12.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
+      logger16.info(LOG_SYSTEM, `Attempting to connect to wallet: ${connectorId}`);
       kit.setWallet(connectorId);
       const result = await kit.getAddress();
       if (result.address) {
@@ -2144,7 +2325,7 @@ var WalletsKitImplementation = class {
         this.currentWalletId = connectorId;
         const newStatus = this.getWalletConnectionStatus();
         this.notifyConnectionListeners(newStatus, prevStatus);
-        logger12.info(
+        logger16.info(
           LOG_SYSTEM,
           `Successfully connected to wallet: ${connectorId}, address: ${result.address}`
         );
@@ -2160,7 +2341,7 @@ var WalletsKitImplementation = class {
         };
       }
     } catch (error) {
-      logger12.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
+      logger16.error(LOG_SYSTEM, `Failed to connect to wallet ${connectorId}:`, error);
       return {
         connected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2177,15 +2358,15 @@ var WalletsKitImplementation = class {
     }
     try {
       const prevStatus = this.getWalletConnectionStatus();
-      logger12.info(LOG_SYSTEM, "Disconnecting wallet");
+      logger16.info(LOG_SYSTEM, "Disconnecting wallet");
       this.currentAddress = null;
       this.currentWalletId = null;
       const newStatus = this.getWalletConnectionStatus();
       this.notifyConnectionListeners(newStatus, prevStatus);
-      logger12.info(LOG_SYSTEM, "Successfully disconnected wallet");
+      logger16.info(LOG_SYSTEM, "Successfully disconnected wallet");
       return { disconnected: true };
     } catch (error) {
-      logger12.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
+      logger16.error(LOG_SYSTEM, "Failed to disconnect wallet:", error);
       return {
         disconnected: false,
         error: error instanceof Error ? error.message : "Unknown error occurred"
@@ -2218,15 +2399,15 @@ var WalletsKitImplementation = class {
    */
   onWalletConnectionChange(callback) {
     if (!this.initialized) {
-      logger12.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
+      logger16.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
       return () => {
       };
     }
     this.connectionStatusListeners.add(callback);
-    logger12.info(LOG_SYSTEM, "Connection status listener added");
+    logger16.info(LOG_SYSTEM, "Connection status listener added");
     return () => {
       this.connectionStatusListeners.delete(callback);
-      logger12.debug(LOG_SYSTEM, "Connection status listener removed");
+      logger16.debug(LOG_SYSTEM, "Connection status listener removed");
     };
   }
   /**
@@ -2255,14 +2436,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();
-    logger12.info(LOG_SYSTEM, "Signing transaction with wallet");
-    return await kit.signTransaction(xdr11, {
+    logger16.info(LOG_SYSTEM, "Signing transaction with wallet");
+    return await kit.signTransaction(xdr13, {
       address,
       networkPassphrase
     });
@@ -2275,7 +2456,7 @@ var WalletsKitImplementation = class {
       try {
         listener(currentStatus, previousStatus);
       } catch (error) {
-        logger12.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
+        logger16.error(LOG_SYSTEM, "Error in connection status listener:", String(error));
       }
     });
   }
@@ -2288,7 +2469,7 @@ var WalletsKitImplementation = class {
       this.unsubscribeFromStatusChanges = void 0;
     }
     this.connectionStatusListeners.clear();
-    logger12.info(LOG_SYSTEM, "Cleanup completed");
+    logger16.info(LOG_SYSTEM, "Cleanup completed");
   }
 };
 
@@ -2312,17 +2493,17 @@ async function getStellarWalletImplementation(networkConfig) {
   }
   walletImplementationPromise = (async () => {
     try {
-      logger13.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
+      logger17.info(LOG_SYSTEM2, "Initializing StellarWalletImplementation singleton (async)...");
       const initialUiKitConfig = appConfigService.getTypedNestedConfig(
         "walletui",
         "config"
       );
       const instance = new WalletsKitImplementation(networkConfig, initialUiKitConfig);
-      logger13.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
+      logger17.info(LOG_SYSTEM2, "WalletsKitImplementation singleton created (async).");
       walletImplementationInstance = instance;
       return instance;
     } catch (error) {
-      logger13.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
+      logger17.error(LOG_SYSTEM2, "Failed to initialize WalletsKitImplementation (async):", error);
       const fallbackInstance = new WalletsKitImplementation(networkConfig);
       walletImplementationInstance = fallbackInstance;
       return fallbackInstance;
@@ -2332,7 +2513,7 @@ async function getStellarWalletImplementation(networkConfig) {
 }
 function getInitializedStellarWalletImplementation() {
   if (!walletImplementationInstance) {
-    logger13.warn(
+    logger17.warn(
       LOG_SYSTEM2,
       "getInitializedStellarWalletImplementation called before instance was ready."
     );
@@ -2342,7 +2523,7 @@ function getInitializedStellarWalletImplementation() {
 
 // src/wallet/stellar-wallets-kit/stellarUiKitManager.ts
 import { allowAllModules as allowAllModules2, StellarWalletsKit as StellarWalletsKit2, WalletNetwork as WalletNetwork2 } from "@creit.tech/stellar-wallets-kit";
-import { logger as logger14 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger18 } from "@openzeppelin/ui-builder-utils";
 var getInitialState = () => ({
   isConfigured: false,
   isInitializing: false,
@@ -2379,13 +2560,13 @@ function setNetworkConfig(config) {
 }
 function getWalletNetwork(networkConfig) {
   if (!networkConfig) {
-    logger14.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
+    logger18.warn("StellarUiKitManager", "No network config available, defaulting to TESTNET");
     return WalletNetwork2.TESTNET;
   }
   return networkConfig.type === "mainnet" ? WalletNetwork2.PUBLIC : WalletNetwork2.TESTNET;
 }
 async function configure(newFullUiKitConfig) {
-  logger14.info(
+  logger18.info(
     "StellarUiKitManager:configure",
     "Configuring UI kit. New config:",
     newFullUiKitConfig
@@ -2415,7 +2596,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      logger14.info(
+      logger18.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured with built-in UI and all wallet modules"
       );
@@ -2429,7 +2610,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = true;
       state.error = null;
-      logger14.info(
+      logger18.info(
         "StellarUiKitManager:configure",
         "Stellar Wallets Kit configured for custom UI components"
       );
@@ -2438,7 +2619,7 @@ async function configure(newFullUiKitConfig) {
       state.kitProviderComponent = null;
       state.isKitAssetsLoaded = false;
       state.error = null;
-      logger14.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
+      logger18.info("StellarUiKitManager:configure", 'UI kit set to "none", no wallet UI provided');
     } else {
       throw new Error(`Unknown UI kit name: ${newKitName}`);
     }
@@ -2451,7 +2632,7 @@ async function configure(newFullUiKitConfig) {
     };
     notifyListeners();
   } catch (error) {
-    logger14.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
+    logger18.error("StellarUiKitManager:configure", "Failed to configure UI kit:", error);
     state = {
       ...state,
       isInitializing: false,
@@ -2555,7 +2736,7 @@ function generateStellarWalletsKitExportables(uiKitConfig) {
 
 // src/wallet/stellar-wallets-kit/StellarWalletsKitConnectButton.tsx
 import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { logger as logger15 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger19 } from "@openzeppelin/ui-builder-utils";
 import { jsx as jsx5 } from "react/jsx-runtime";
 function StellarWalletsKitConnectButton() {
   const containerRef = useRef2(null);
@@ -2563,7 +2744,7 @@ function StellarWalletsKitConnectButton() {
     const state2 = stellarUiKitManager.getState();
     const kit = state2.stellarKitProvider;
     if (!kit || !containerRef.current) {
-      logger15.error(
+      logger19.error(
         "StellarWalletsKitConnectButton",
         "Kit not initialized or container not available"
       );
@@ -2572,10 +2753,10 @@ function StellarWalletsKitConnectButton() {
     kit.createButton({
       container: containerRef.current,
       onConnect: ({ address }) => {
-        logger15.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
+        logger19.info("StellarWalletsKitConnectButton", `Connected to address: ${address}`);
       },
       onDisconnect: () => {
-        logger15.info("StellarWalletsKitConnectButton", "Disconnected");
+        logger19.info("StellarWalletsKitConnectButton", "Disconnected");
       },
       buttonText: "Connect Wallet"
     });
@@ -2584,10 +2765,10 @@ function StellarWalletsKitConnectButton() {
         try {
           kit.removeButton();
         } catch (error) {
-          logger15.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
+          logger19.warn("StellarWalletsKitConnectButton", "Error removing button:", error);
         }
       } else {
-        logger15.warn(
+        logger19.warn(
           "StellarWalletsKitConnectButton",
           "removeButton method not available on kit instance"
         );
@@ -2616,7 +2797,7 @@ async function disconnectStellarWallet() {
 function getStellarWalletConnectionStatus() {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    logger16.warn(
+    logger20.warn(
       "getStellarWalletConnectionStatus",
       "Wallet implementation not ready. Returning default disconnected state."
     );
@@ -2638,7 +2819,7 @@ function getStellarWalletConnectionStatus() {
 function onStellarWalletConnectionChange(callback) {
   const impl = getInitializedStellarWalletImplementation();
   if (!impl) {
-    logger16.warn(
+    logger20.warn(
       "onStellarWalletConnectionChange",
       "Wallet implementation not ready. Returning no-op."
     );
@@ -2661,13 +2842,13 @@ function onStellarWalletConnectionChange(callback) {
     try {
       callback(currentStatus, previousStatus);
     } catch (error) {
-      logger16.error("Error in Stellar connection status listener:", String(error));
+      logger20.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
@@ -2706,7 +2887,7 @@ var RelayerExecutionStrategy = class {
    * @throws If the API call fails or returns an unsuccessful response.
    */
   async getStellarRelayers(serviceUrl, accessToken, networkConfig) {
-    logger17.info(
+    logger21.info(
       "[StellarRelayer] Getting relayers with access token",
       accessToken.slice(0, 5).padEnd(accessToken.length, "*")
     );
@@ -2754,7 +2935,7 @@ var RelayerExecutionStrategy = class {
    * @throws If any API call fails or returns an unsuccessful response.
    */
   async getStellarRelayer(serviceUrl, accessToken, relayerId, _networkConfig) {
-    logger17.info("[StellarRelayer] Getting detailed relayer info", relayerId);
+    logger21.info("[StellarRelayer] Getting detailed relayer info", relayerId);
     const sdkConfig = new Configuration({
       basePath: serviceUrl,
       accessToken
@@ -2764,11 +2945,11 @@ var RelayerExecutionStrategy = class {
       const [relayerResponse, balanceResponse, statusResponse] = await Promise.all([
         relayersApi.getRelayer(relayerId),
         relayersApi.getRelayerBalance(relayerId).catch((err) => {
-          logger17.warn("[StellarRelayer] Failed to fetch balance", err);
+          logger21.warn("[StellarRelayer] Failed to fetch balance", err);
           return null;
         }),
         relayersApi.getRelayerStatus(relayerId).catch((err) => {
-          logger17.warn("[StellarRelayer] Failed to fetch status", err);
+          logger21.warn("[StellarRelayer] Failed to fetch status", err);
           return null;
         })
       ]);
@@ -2790,7 +2971,7 @@ var RelayerExecutionStrategy = class {
           const balanceInXlm = balanceInStroops / 1e7;
           enhancedDetails.balance = `${balanceInXlm.toFixed(7)} XLM`;
         } catch (error) {
-          logger17.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
+          logger21.warn("[StellarRelayer] Failed to format balance, using raw value", String(error));
           enhancedDetails.balance = String(balanceResponse.data.data.balance);
         }
       }
@@ -2809,13 +2990,13 @@ var RelayerExecutionStrategy = class {
           }
         }
       }
-      logger17.info(
+      logger21.info(
         "[StellarRelayer] Retrieved enhanced relayer details",
         JSON.stringify(enhancedDetails)
       );
       return enhancedDetails;
     } catch (error) {
-      logger17.error(
+      logger21.error(
         "[StellarRelayer] Failed to get relayer details",
         error instanceof Error ? error.message : String(error)
       );
@@ -2903,7 +3084,7 @@ var RelayerExecutionStrategy = class {
     const connectedAddress = this.getConnectedWalletAddress();
     const accountResponse = await rpcServer.getAccount(connectedAddress);
     const sourceAccount = new Account2(connectedAddress, accountResponse.sequenceNumber());
-    const contract2 = new Contract2(txData.contractAddress);
+    const contract2 = new Contract3(txData.contractAddress);
     const transactionBuilder = new TransactionBuilder2(sourceAccount, {
       fee: BASE_FEE2,
       networkPassphrase: stellarConfig.networkPassphrase
@@ -2917,7 +3098,7 @@ var RelayerExecutionStrategy = class {
     transactionBuilder.setTimeout(30);
     let transaction = transactionBuilder.build();
     const simulation = await rpcServer.simulateTransaction(transaction);
-    if (StellarRpc2.Api.isSimulationError(simulation)) {
+    if (StellarRpc3.Api.isSimulationError(simulation)) {
       throw new Error(`Transaction simulation failed: ${simulation.error}`);
     }
     transaction = await rpcServer.prepareTransaction(transaction);
@@ -2940,7 +3121,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 StellarRpc2.Server(rpcUrl, { allowHttp });
+    return new StellarRpc3.Server(rpcUrl, { allowHttp });
   }
   getConnectedWalletAddress() {
     const connectionStatus = getStellarWalletConnectionStatus();
@@ -3071,10 +3252,10 @@ var RelayerExecutionStrategy = class {
 };
 
 // src/configuration/execution.ts
-import { logger as logger18 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger22 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG7 = "adapter-stellar-execution-config";
 async function getStellarSupportedExecutionMethods() {
-  logger18.warn(
+  logger22.warn(
     "adapter-stellar-execution-config",
     "getStellarSupportedExecutionMethods is using placeholder implementation."
   );
@@ -3100,11 +3281,11 @@ async function getStellarSupportedExecutionMethods() {
   ]);
 }
 async function _validateMultisigConfig(_config, _walletStatus) {
-  logger18.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
+  logger22.info(SYSTEM_LOG_TAG7, "Multisig execution config validation: Not yet fully implemented.");
   return true;
 }
 async function validateStellarExecutionConfig(config, walletStatus) {
-  logger18.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
+  logger22.info(SYSTEM_LOG_TAG7, "Validating Stellar execution config:", { config, walletStatus });
   switch (config.method) {
     case "eoa":
       return validateEoaConfig(config, walletStatus);
@@ -3114,7 +3295,7 @@ async function validateStellarExecutionConfig(config, walletStatus) {
       return _validateMultisigConfig(config, walletStatus);
     default: {
       const unknownMethod = config.method;
-      logger18.warn(
+      logger22.warn(
         SYSTEM_LOG_TAG7,
         `Unsupported execution method type encountered: ${unknownMethod}`
       );
@@ -3127,18 +3308,18 @@ async function validateStellarExecutionConfig(config, walletStatus) {
 import {
   appConfigService as appConfigService2,
   isValidUrl,
-  logger as logger19,
-  userRpcConfigService as userRpcConfigService2
+  logger as logger23,
+  userRpcConfigService as userRpcConfigService3
 } from "@openzeppelin/ui-builder-utils";
 function validateStellarRpcEndpoint(rpcConfig) {
   try {
     if (!isValidUrl(rpcConfig.url)) {
-      logger19.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
+      logger23.error("validateStellarRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
       return false;
     }
     return true;
   } catch (error) {
-    logger19.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
+    logger23.error("validateStellarRpcEndpoint", "Error validating RPC endpoint:", error);
     return false;
   }
 }
@@ -3186,7 +3367,7 @@ async function testStellarRpcConnection(rpcConfig, timeoutMs = 5e3) {
     }
     return { success: true, latency };
   } catch (error) {
-    logger19.error("testStellarRpcConnection", "Connection test failed:", error);
+    logger23.error("testStellarRpcConnection", "Connection test failed:", error);
     if (error instanceof Error && error.name === "AbortError") {
       return {
         success: false,
@@ -3405,11 +3586,11 @@ function getStellarCompatibleFieldTypes(parameterType) {
 
 // src/mapping/field-generator.ts
 import { startCase } from "lodash";
-import { getDefaultValueForType, logger as logger21 } from "@openzeppelin/ui-builder-utils";
+import { getDefaultValueForType, logger as logger25 } from "@openzeppelin/ui-builder-utils";
 
 // src/mapping/enum-metadata.ts
-import { xdr as xdr9 } from "@stellar/stellar-sdk";
-import { logger as logger20 } from "@openzeppelin/ui-builder-utils";
+import { xdr as xdr11 } from "@stellar/stellar-sdk";
+import { logger as logger24 } from "@openzeppelin/ui-builder-utils";
 function extractEnumVariants(entries, enumName) {
   try {
     const entry = entries.find((e) => {
@@ -3423,20 +3604,20 @@ function extractEnumVariants(entries, enumName) {
       return null;
     }
     const entryKind = entry.switch();
-    if (entryKind.value === xdr9.ScSpecEntryKind.scSpecEntryUdtUnionV0().value) {
+    if (entryKind.value === xdr11.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 === xdr9.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseVoidV0().value) {
+        if (caseKind.value === xdr11.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseVoidV0().value) {
           const voidCase = caseEntry.voidCase();
           variants.push({
             name: voidCase.name().toString(),
             type: "void"
           });
-        } else if (caseKind.value === xdr9.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseTupleV0().value) {
+        } else if (caseKind.value === xdr11.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseTupleV0().value) {
           const tupleCase = caseEntry.tupleCase();
           const payloadTypes = tupleCase.type().map((typeDef) => extractSorobanTypeFromScSpec(typeDef));
           variants.push({
@@ -3453,7 +3634,7 @@ function extractEnumVariants(entries, enumName) {
         isUnitOnly
       };
     }
-    if (entryKind.value === xdr9.ScSpecEntryKind.scSpecEntryUdtEnumV0().value) {
+    if (entryKind.value === xdr11.ScSpecEntryKind.scSpecEntryUdtEnumV0().value) {
       const enumUdt = entry.udtEnumV0();
       const cases = enumUdt.cases();
       const variants = [];
@@ -3473,7 +3654,7 @@ function extractEnumVariants(entries, enumName) {
     }
     return null;
   } catch (error) {
-    logger20.error("extractEnumVariants", `Failed to extract enum variants for ${enumName}:`, error);
+    logger24.error("extractEnumVariants", `Failed to extract enum variants for ${enumName}:`, error);
     return null;
   }
 }
@@ -3491,10 +3672,10 @@ function isEnumType(entries, typeName) {
       return false;
     }
     const entryKind = entry.switch();
-    const isEnum = entryKind.value === xdr9.ScSpecEntryKind.scSpecEntryUdtUnionV0().value || entryKind.value === xdr9.ScSpecEntryKind.scSpecEntryUdtEnumV0().value;
+    const isEnum = entryKind.value === xdr11.ScSpecEntryKind.scSpecEntryUdtUnionV0().value || entryKind.value === xdr11.ScSpecEntryKind.scSpecEntryUdtEnumV0().value;
     return isEnum;
   } catch (error) {
-    logger20.error("isEnumType", `Failed to check if ${typeName} is enum:`, error);
+    logger24.error("isEnumType", `Failed to check if ${typeName} is enum:`, error);
     return false;
   }
 }
@@ -3507,12 +3688,13 @@ function generateStellarDefaultField(parameter, contractSchema) {
   const specEntries = contractSchema?.metadata?.specEntries;
   const fieldType = mapStellarParameterTypeToFieldType(parameter.type);
   if (parameter.type === "unknown") {
-    logger21.warn(
+    logger25.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)) {
@@ -3539,6 +3721,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,
@@ -3610,12 +3798,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 = {
@@ -3630,9 +3821,9 @@ function generateStellarDefaultField(parameter, contractSchema) {
 // src/transaction/formatter.ts
 import { Address as Address3 } from "@stellar/stellar-sdk";
 import { isEnumValue as isEnumValue3 } from "@openzeppelin/ui-builder-types";
-import { logger as logger22 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger26 } from "@openzeppelin/ui-builder-utils";
 function formatStellarTransactionData(contractSchema, functionId, submittedInputs, fields) {
-  logger22.info(
+  logger26.info(
     "formatStellarTransactionData",
     `Formatting Stellar transaction data for function: ${functionId}`
   );
@@ -3650,7 +3841,7 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
     let value;
     if (fieldConfig.isHardcoded) {
       if (fieldConfig.hardcodedValue === void 0 && fieldConfig.name in submittedInputs) {
-        logger22.warn(
+        logger26.warn(
           "formatStellarTransactionData",
           `Field '${fieldConfig.name}' is hardcoded with undefined value but has submitted input. Using submitted input instead.`
         );
@@ -3722,7 +3913,7 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
       // For example: fee, timeout, memo, etc.
     }
   };
-  logger22.debug(
+  logger26.debug(
     "formatStellarTransactionData",
     "Formatted transaction data:",
     stellarTransactionData
@@ -3731,33 +3922,33 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
 }
 
 // src/transaction/sender.ts
-import { rpc as StellarRpc4 } from "@stellar/stellar-sdk";
-import { logger as logger24, userRpcConfigService as userRpcConfigService4 } from "@openzeppelin/ui-builder-utils";
+import { rpc as StellarRpc5 } from "@stellar/stellar-sdk";
+import { logger as logger28, userRpcConfigService as userRpcConfigService5 } from "@openzeppelin/ui-builder-utils";
 
 // src/transaction/eoa.ts
 import {
   Account as Account3,
   BASE_FEE as BASE_FEE3,
-  Contract as Contract3,
-  rpc as StellarRpc3,
+  Contract as Contract4,
+  rpc as StellarRpc4,
   TransactionBuilder as TransactionBuilder3
 } from "@stellar/stellar-sdk";
-import { logger as logger23, userRpcConfigService as userRpcConfigService3 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger27, userRpcConfigService as userRpcConfigService4 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG8 = "EoaExecutionStrategy";
-function getSorobanRpcServer2(networkConfig) {
-  const customRpcConfig = userRpcConfigService3.getUserRpcConfig(networkConfig.id);
+function getSorobanRpcServer3(networkConfig) {
+  const customRpcConfig = userRpcConfigService4.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 StellarRpc3.Server(rpcUrl, {
+  return new StellarRpc4.Server(rpcUrl, {
     allowHttp
   });
 }
 var EoaExecutionStrategy = class {
   async execute(transactionData, executionConfig, networkConfig, onStatusChange, _runtimeApiKey) {
-    logger23.info(SYSTEM_LOG_TAG8, "Using Stellar EOA execution strategy");
+    logger27.info(SYSTEM_LOG_TAG8, "Using Stellar EOA execution strategy");
     if (executionConfig.method !== "eoa") {
       throw new Error(`Expected EOA execution config, got: ${executionConfig.method}`);
     }
@@ -3765,9 +3956,9 @@ var EoaExecutionStrategy = class {
   }
   async executeEoaTransaction(txData, stellarConfig, onStatusChange) {
     try {
-      const rpcServer = getSorobanRpcServer2(stellarConfig);
+      const rpcServer = getSorobanRpcServer3(stellarConfig);
       const connectedAddress = this.getConnectedWalletAddress();
-      logger23.info(SYSTEM_LOG_TAG8, `Connected address: ${connectedAddress}`);
+      logger27.info(SYSTEM_LOG_TAG8, `Connected address: ${connectedAddress}`);
       let sourceAccount;
       try {
         const accountResponse = await rpcServer.getAccount(connectedAddress);
@@ -3775,7 +3966,7 @@ var EoaExecutionStrategy = class {
       } catch (error) {
         throw new Error(`Failed to load account details: ${error.message}`);
       }
-      const contract2 = new Contract3(txData.contractAddress);
+      const contract2 = new Contract4(txData.contractAddress);
       const transactionBuilder = new TransactionBuilder3(sourceAccount, {
         fee: BASE_FEE3,
         networkPassphrase: stellarConfig.networkPassphrase
@@ -3790,7 +3981,7 @@ var EoaExecutionStrategy = class {
       let transaction = transactionBuilder.build();
       try {
         const simulation = await rpcServer.simulateTransaction(transaction);
-        if (StellarRpc3.Api.isSimulationError(simulation)) {
+        if (StellarRpc4.Api.isSimulationError(simulation)) {
           throw new Error(`Transaction simulation failed: ${simulation.error}`);
         }
         transaction = await rpcServer.prepareTransaction(transaction);
@@ -3826,7 +4017,7 @@ var EoaExecutionStrategy = class {
         throw new Error(`Transaction failed to submit: ${sendResult.status}`);
       }
       const txHash = sendResult.hash;
-      logger23.info(SYSTEM_LOG_TAG8, `Transaction submitted successfully: ${txHash}`);
+      logger27.info(SYSTEM_LOG_TAG8, `Transaction submitted successfully: ${txHash}`);
       try {
         let txResponse;
         const MAX_ATTEMPTS = 10;
@@ -3845,10 +4036,10 @@ var EoaExecutionStrategy = class {
           }
         }
         if (attempts >= MAX_ATTEMPTS || txResponse?.status !== "SUCCESS") {
-          logger23.warn(SYSTEM_LOG_TAG8, `Transaction confirmation timeout for ${txHash}`);
+          logger27.warn(SYSTEM_LOG_TAG8, `Transaction confirmation timeout for ${txHash}`);
         }
       } catch (confirmError) {
-        logger23.error(SYSTEM_LOG_TAG8, "Error waiting for confirmation:", confirmError);
+        logger27.error(SYSTEM_LOG_TAG8, "Error waiting for confirmation:", confirmError);
       }
       onStatusChange("success", {
         txHash
@@ -3856,7 +4047,7 @@ var EoaExecutionStrategy = class {
       return { txHash };
     } catch (error) {
       const errorMessage = `Failed to execute Stellar EOA transaction: ${error.message}`;
-      logger23.error(SYSTEM_LOG_TAG8, errorMessage, error);
+      logger27.error(SYSTEM_LOG_TAG8, errorMessage, error);
       onStatusChange("error", {});
       throw new Error(errorMessage);
     }
@@ -3873,7 +4064,7 @@ var EoaExecutionStrategy = class {
 // src/transaction/sender.ts
 var SYSTEM_LOG_TAG9 = "adapter-stellar";
 async function signAndBroadcastStellarTransaction(transactionData, executionConfig, networkConfig, onStatusChange, runtimeApiKey) {
-  logger24.info(
+  logger28.info(
     SYSTEM_LOG_TAG9,
     "Stellar signAndBroadcast called with executionConfig:",
     executionConfig
@@ -3894,7 +4085,7 @@ async function signAndBroadcastStellarTransaction(transactionData, executionConf
       throw new Error("Multisig execution method not yet implemented for Stellar.");
     default: {
       const exhaustiveCheck = executionConfig;
-      logger24.error(SYSTEM_LOG_TAG9, `Unsupported execution method encountered: ${exhaustiveCheck}`);
+      logger28.error(SYSTEM_LOG_TAG9, `Unsupported execution method encountered: ${exhaustiveCheck}`);
       throw new Error(`Unsupported execution method: ${exhaustiveCheck}`);
     }
   }
@@ -3910,7 +4101,7 @@ async function signAndBroadcastStellarTransaction(transactionData, executionConf
 
 // src/wallet/components/StellarWalletUiRoot.tsx
 import { useCallback, useEffect as useEffect3, useState as useState2 } from "react";
-import { logger as logger25 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger29 } from "@openzeppelin/ui-builder-utils";
 
 // src/wallet/context/StellarWalletContext.ts
 import { createContext } from "react";
@@ -3929,9 +4120,9 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
     const currentState = stellarUiKitManager.getState();
     if (uiKitConfig || !currentState.currentFullUiKitConfig) {
       const configToUse = uiKitConfig || { kitName: "custom", kitConfig: {} };
-      logger25.debug("StellarWalletUiRoot", "Configuring UI kit with:", configToUse);
+      logger29.debug("StellarWalletUiRoot", "Configuring UI kit with:", configToUse);
       stellarUiKitManager.configure(configToUse).catch((error) => {
-        logger25.error("Failed to configure Stellar UI kit:", error);
+        logger29.error("Failed to configure Stellar UI kit:", error);
       });
     }
   }, [uiKitConfig]);
@@ -3945,7 +4136,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
     const unsubscribeFromConnectionChanges = onStellarWalletConnectionChange(
       (currentStatus, _previousStatus) => {
         setAddress(currentStatus.address || null);
-        logger25.debug(
+        logger29.debug(
           "StellarWalletUiRoot",
           `Connection status changed: ${currentStatus.isConnected ? "connected" : "disconnected"}`,
           currentStatus.address
@@ -3964,7 +4155,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         const connectors = await getStellarAvailableConnectors();
         setAvailableWallets(connectors);
       } catch (error) {
-        logger25.error("Failed to load available wallets:", String(error));
+        logger29.error("Failed to load available wallets:", String(error));
       }
     };
     if (!uiKitManagerState.isInitializing && uiKitManagerState.stellarKitProvider) {
@@ -3981,7 +4172,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         throw new Error(result.error || "Failed to connect wallet");
       }
     } catch (error) {
-      logger25.error("Failed to connect:", String(error));
+      logger29.error("Failed to connect:", String(error));
       throw error;
     } finally {
       setIsConnecting(false);
@@ -3996,7 +4187,7 @@ function StellarWalletUiRoot({ children, uiKitConfig }) {
         throw new Error(result.error || "Failed to disconnect wallet");
       }
     } catch (error) {
-      logger25.error("Failed to disconnect:", String(error));
+      logger29.error("Failed to disconnect:", String(error));
       throw error;
     }
   }, []);
@@ -4115,20 +4306,20 @@ var stellarFacadeHooks = {
 };
 
 // src/wallet/hooks/useUiKitConfig.ts
-import { appConfigService as appConfigService3, logger as logger26 } from "@openzeppelin/ui-builder-utils";
+import { appConfigService as appConfigService3, logger as logger30 } from "@openzeppelin/ui-builder-utils";
 var defaultConfig = {
   kitName: "custom",
   // Default to using our custom implementation for Stellar
   kitConfig: {}
 };
 function loadInitialConfigFromAppService() {
-  logger26.debug(
+  logger30.debug(
     "stellar:useUiKitConfig",
     "Attempting to load initial config from AppConfigService..."
   );
   const configObj = appConfigService3.getWalletUIConfig("stellar");
   if (configObj && configObj.kitName) {
-    logger26.info(
+    logger30.info(
       "stellar:useUiKitConfig",
       `Loaded initial config from AppConfigService: kitName=${configObj.kitName}`,
       configObj.kitConfig
@@ -4138,7 +4329,7 @@ function loadInitialConfigFromAppService() {
       kitConfig: { ...defaultConfig.kitConfig, ...configObj.kitConfig || {} }
     };
   }
-  logger26.debug(
+  logger30.debug(
     "stellar:useUiKitConfig",
     "No initial config found in AppConfigService, using module default."
   );
@@ -4161,7 +4352,7 @@ import {
   DialogHeader,
   DialogTitle
 } from "@openzeppelin/ui-builder-ui";
-import { logger as logger27 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger31 } from "@openzeppelin/ui-builder-utils";
 import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var ConnectorDialog = ({ open, onOpenChange }) => {
   const { connect } = useStellarConnect();
@@ -4176,7 +4367,7 @@ var ConnectorDialog = ({ open, onOpenChange }) => {
         const availableConnectors = await getStellarAvailableConnectors();
         setConnectors(availableConnectors);
       } catch (err) {
-        logger27.error("Failed to load Stellar connectors:", String(err));
+        logger31.error("Failed to load Stellar connectors:", String(err));
         setError("Failed to load available wallets");
       } finally {
         setLoadingConnectors(false);
@@ -4330,18 +4521,18 @@ var CustomAccountDisplay = ({ className }) => {
 
 // src/wallet/utils/filterWalletComponents.ts
 import { ECOSYSTEM_WALLET_COMPONENT_KEYS } from "@openzeppelin/ui-builder-types";
-import { logger as logger28 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger32 } from "@openzeppelin/ui-builder-utils";
 function filterWalletComponents(allPossibleComponents, exclusions, kitName = "custom") {
-  logger28.debug(
+  logger32.debug(
     "filterWalletComponents",
     `Filtering components for kit: ${kitName}. Exclusions: ${exclusions.join(", ")}.`
   );
   if (!allPossibleComponents || Object.keys(allPossibleComponents).length === 0) {
-    logger28.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
+    logger32.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
     return void 0;
   }
   if (exclusions.length === 0) {
-    logger28.debug(
+    logger32.debug(
       "filterWalletComponents",
       `Providing all components for kit: ${kitName}.`,
       allPossibleComponents
@@ -4360,14 +4551,14 @@ function filterWalletComponents(allPossibleComponents, exclusions, kitName = "cu
     }
   }
   if (componentCount > 0) {
-    logger28.debug(
+    logger32.debug(
       "filterWalletComponents",
       `Providing filtered components for kit: ${kitName} after exclusions (${exclusions.join(", ")}).`,
       filteredComponents
     );
     return filteredComponents;
   }
-  logger28.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
+  logger32.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
   return void 0;
 }
 function getComponentExclusionsFromConfig(kitConfig) {
@@ -4383,23 +4574,23 @@ function getComponentExclusionsFromConfig(kitConfig) {
 }
 
 // src/wallet/utils/uiKitService.ts
-import { logger as logger29 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger33 } from "@openzeppelin/ui-builder-utils";
 function getResolvedWalletComponents(uiKitConfiguration) {
-  logger29.debug(
+  logger33.debug(
     "stellar:uiKitService:getResolvedWalletComponents",
     "Received uiKitConfiguration:",
     JSON.stringify(uiKitConfiguration)
   );
   const currentKitName = uiKitConfiguration.kitName || "custom";
   if (currentKitName === "none") {
-    logger29.info(
+    logger33.info(
       "stellar:uiKitService",
       'UI Kit set to "none" for getResolvedWalletComponents, not providing wallet components.'
     );
     return void 0;
   }
   const exclusions = getComponentExclusionsFromConfig(uiKitConfiguration.kitConfig);
-  logger29.debug(
+  logger33.debug(
     "stellar:uiKitService",
     `Extracted component exclusions for ${currentKitName}: ${exclusions.join(", ") || "none"}.`
   );
@@ -4409,7 +4600,7 @@ function getResolvedWalletComponents(uiKitConfiguration) {
       AccountDisplay: CustomAccountDisplay
       // NetworkSwitcher is not included as Stellar doesn't support network switching
     };
-    logger29.info(
+    logger33.info(
       "stellar:uiKitService",
       `Providing custom Stellar wallet components for kit: ${currentKitName}`
     );
@@ -4421,10 +4612,10 @@ function getResolvedWalletComponents(uiKitConfiguration) {
       // The kit's native button handles account display internally
       AccountDisplay: void 0
     };
-    logger29.info("stellar:uiKitService", "Using Stellar Wallets Kit native button");
+    logger33.info("stellar:uiKitService", "Using Stellar Wallets Kit native button");
     return stellarKitComponents;
   }
-  logger29.warn(
+  logger33.warn(
     "stellar:uiKitService",
     `UI Kit "${currentKitName}" for getResolvedWalletComponents not explicitly supported. No components provided.`
   );
@@ -4432,9 +4623,9 @@ function getResolvedWalletComponents(uiKitConfiguration) {
 }
 
 // src/wallet/services/configResolutionService.ts
-import { logger as logger30 } from "@openzeppelin/ui-builder-utils";
+import { logger as logger34 } from "@openzeppelin/ui-builder-utils";
 async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppServiceKitName, currentAppServiceConfig, options) {
-  logger30.debug(
+  logger34.debug(
     "stellar:configResolutionService:resolveFullUiKitConfiguration",
     "Starting resolution with:",
     {
@@ -4445,7 +4636,7 @@ async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppSe
     }
   );
   if (options?.loadUiKitNativeConfig) {
-    logger30.debug(
+    logger34.debug(
       "stellar:configResolutionService",
       "Native config loader provided but not currently supported for Stellar adapter"
     );
@@ -4458,7 +4649,7 @@ async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppSe
       ...programmaticOverrides.kitConfig || {}
     }
   };
-  logger30.debug(
+  logger34.debug(
     "stellar:configResolutionService:resolveFullUiKitConfiguration",
     "Resolved finalFullConfig:",
     finalFullConfig
@@ -4477,7 +4668,7 @@ var StellarAdapter = class {
     this.networkConfig = networkConfig;
     stellarUiKitManager.setNetworkConfig(networkConfig);
     getStellarWalletImplementation(networkConfig).catch((error) => {
-      logger31.error(
+      logger35.error(
         "StellarAdapter:constructor",
         "Failed to initialize wallet implementation:",
         error
@@ -4485,12 +4676,12 @@ var StellarAdapter = class {
     });
     const initialGlobalConfig = loadInitialConfigFromAppService();
     this.initialAppServiceKitName = initialGlobalConfig.kitName || "custom";
-    logger31.info(
+    logger35.info(
       "StellarAdapter:constructor",
       "Initial kitName from AppConfigService noted:",
       this.initialAppServiceKitName
     );
-    logger31.info(
+    logger35.info(
       "StellarAdapter",
       `Adapter initialized for network: ${networkConfig.name} (ID: ${networkConfig.id})`
     );
@@ -4637,7 +4828,7 @@ var StellarAdapter = class {
   onWalletConnectionChange(callback) {
     const walletImplementation = getInitializedStellarWalletImplementation();
     if (!walletImplementation) {
-      logger31.warn(
+      logger35.warn(
         "StellarAdapter:onWalletConnectionChange",
         "Wallet implementation not ready. Subscription may not work."
       );
@@ -4699,7 +4890,7 @@ var StellarAdapter = class {
       options
     );
     await stellarUiKitManager.configure(finalFullConfig);
-    logger31.info(
+    logger35.info(
       "StellarAdapter:configureUiKit",
       "StellarUiKitManager configuration requested with final config:",
       finalFullConfig
@@ -4720,7 +4911,7 @@ var StellarAdapter = class {
   getEcosystemWalletComponents() {
     const currentManagerState = stellarUiKitManager.getState();
     if (!currentManagerState.currentFullUiKitConfig) {
-      logger31.debug(
+      logger35.debug(
         "StellarAdapter:getEcosystemWalletComponents",
         "No UI kit configuration available in manager yet. Returning undefined components."
       );
@@ -4733,7 +4924,7 @@ var StellarAdapter = class {
    * @inheritdoc
    */
   getEcosystemReactUiContextProvider() {
-    logger31.info(
+    logger35.info(
       "StellarAdapter:getEcosystemReactUiContextProvider",
       "Returning StellarWalletUiRoot."
     );
@@ -4750,7 +4941,7 @@ var StellarAdapter = class {
     try {
       return await relayerStrategy.getStellarRelayers(serviceUrl, accessToken, this.networkConfig);
     } catch (error) {
-      logger31.error("StellarAdapter", "Failed to fetch Stellar relayers:", error);
+      logger35.error("StellarAdapter", "Failed to fetch Stellar relayers:", error);
       return Promise.resolve([]);
     }
   }
@@ -4764,7 +4955,7 @@ var StellarAdapter = class {
         this.networkConfig
       );
     } catch (error) {
-      logger31.error("StellarAdapter", "Failed to fetch Stellar relayer details:", error);
+      logger35.error("StellarAdapter", "Failed to fetch Stellar relayer details:", error);
       return Promise.resolve({});
     }
   }
@@ -4814,6 +5005,7 @@ var StellarAdapter = class {
 };
 
 // src/networks/mainnet.ts
+import { NetworkStellar } from "@web3icons/react";
 var stellarPublic = {
   id: "stellar-public",
   exportConstName: "stellarPublic",
@@ -4826,10 +5018,11 @@ var stellarPublic = {
   sorobanRpcUrl: "https://mainnet.sorobanrpc.com",
   networkPassphrase: "Public Global Stellar Network ; September 2015",
   explorerUrl: "https://stellar.expert/explorer/public",
-  icon: "stellar"
+  iconComponent: NetworkStellar
 };
 
 // src/networks/testnet.ts
+import { NetworkStellar as NetworkStellar2 } from "@web3icons/react";
 var stellarTestnet = {
   id: "stellar-testnet",
   exportConstName: "stellarTestnet",
@@ -4842,7 +5035,7 @@ var stellarTestnet = {
   sorobanRpcUrl: "https://soroban-testnet.stellar.org",
   networkPassphrase: "Test SDF Network ; September 2015",
   explorerUrl: "https://stellar.expert/explorer/testnet",
-  icon: "stellar"
+  iconComponent: NetworkStellar2
 };
 
 // src/networks/index.ts
@@ -4864,6 +5057,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)