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

package/dist/index.js

@@ -443,10 +443,17 @@ function extractStructFields(entries, structName) {
       for (const field of fields) {
         const fieldName = field.name().toString();
         const fieldType = extractSorobanTypeFromScSpec(field.type());
-        structFields.push({
+        const fieldParam = {
           name: fieldName,
           type: fieldType
-        });
+        };
+        if (isStructType(entries, fieldType)) {
+          const nestedFields = extractStructFields(entries, fieldType);
+          if (nestedFields && nestedFields.length > 0) {
+            fieldParam.components = nestedFields;
+          }
+        }
+        structFields.push(fieldParam);
       }
       return structFields;
     }
@@ -496,7 +503,7 @@ import {
 import { logger as logger11, userRpcConfigService as userRpcConfigService2 } from "@openzeppelin/ui-builder-utils";
 
 // src/transform/parsers/index.ts
-import { isEnumValue as isEnumValue2 } from "@openzeppelin/ui-builder-types";
+import { isEnumValue as isEnumValue3 } from "@openzeppelin/ui-builder-types";
 import { isPlainObject as isPlainObject2, logger as logger9 } from "@openzeppelin/ui-builder-utils";
 
 // src/transform/parsers/generic-parser.ts
@@ -739,6 +746,20 @@ function extractOptionElementType(parameterType) {
   }
   return extractGenericInnerType(parameterType, "Option");
 }
+function extractTupleTypes(parameterType) {
+  if (!isValidTypeString(parameterType) || !parameterType.startsWith("Tuple<")) {
+    return null;
+  }
+  const innerContent = extractGenericInnerType(parameterType, "Tuple");
+  if (!innerContent) {
+    return null;
+  }
+  const parts = splitTopLevelTypes(innerContent);
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts;
+}
 function extractGenericInnerType(parameterType, genericName) {
   const prefix = `${genericName}<`;
   if (!parameterType.startsWith(prefix) || !parameterType.endsWith(">")) {
@@ -812,6 +833,30 @@ function hasInvalidCharacters(str) {
   }
   return !/^[A-Za-z0-9<>,\s_]+$/.test(str);
 }
+function splitTopLevelTypes(content) {
+  const types = [];
+  let start = 0;
+  let level = 0;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    if (char === "<") {
+      level += 1;
+    } else if (char === ">") {
+      level -= 1;
+    } else if (char === "," && level === 0) {
+      const segment = content.slice(start, i).trim();
+      if (segment) {
+        types.push(segment);
+      }
+      start = i + 1;
+    }
+  }
+  const lastSegment = content.slice(start).trim();
+  if (lastSegment) {
+    types.push(lastSegment);
+  }
+  return types;
+}
 
 // src/utils/formatting.ts
 function stringifyWithBigInt(value, space) {
@@ -886,6 +931,34 @@ function convertStellarTypeToScValType(stellarType) {
 // src/utils/input-parsing.ts
 import { nativeToScVal, xdr as xdr3 } from "@stellar/stellar-sdk";
 import { detectBytesEncoding as detectBytesEncoding2, logger as logger7, stringToBytes as stringToBytes2 } from "@openzeppelin/ui-builder-utils";
+
+// src/utils/xdr-ordering.ts
+function compareScValsByXdr(a, b) {
+  const aBytes = getBytes(a);
+  const bBytes = getBytes(b);
+  const minLength = Math.min(aBytes.length, bBytes.length);
+  for (let index = 0; index < minLength; index += 1) {
+    const diff = aBytes[index] - bBytes[index];
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return aBytes.length - bBytes.length;
+}
+function getBytes(scVal) {
+  const xdrValue = scVal.toXDR();
+  if (xdrValue instanceof Uint8Array) {
+    return xdrValue;
+  }
+  const arrayLike = xdrValue;
+  const result = new Uint8Array(arrayLike.length);
+  for (let index = 0; index < arrayLike.length; index += 1) {
+    result[index] = arrayLike[index];
+  }
+  return result;
+}
+
+// src/utils/input-parsing.ts
 var SYSTEM_LOG_TAG4 = "StellarInputParsingUtils";
 function isMapArray(argValue) {
   try {
@@ -969,19 +1042,34 @@ function convertEnumToScVal(obj, scVals) {
 }
 function convertObjectToMap(mapArray) {
   try {
-    const mapVal = mapArray.reduce((acc, pair) => {
-      const key = pair["0"].value;
+    const sortedEntries = [...mapArray].sort((a, b) => {
+      const aKey = getScValFromPrimitive(a["0"]);
+      const bKey = getScValFromPrimitive(b["0"]);
+      return compareScValsByXdr(aKey, bKey);
+    });
+    const mapVal = sortedEntries.reduce((acc, pair) => {
+      const key = String(pair["0"].value);
       if (Array.isArray(pair["1"])) {
         const valueScVal = getScValFromArg(pair["1"], []);
         acc[key] = valueScVal;
       } else {
         const value = pair["1"].value;
-        acc[key] = pair["1"].type === "bool" ? value === "true" : value;
+        if (pair["1"].type === "bool") {
+          if (typeof value === "boolean") {
+            acc[key] = value;
+          } else if (typeof value === "string") {
+            acc[key] = value === "true";
+          } else {
+            acc[key] = Boolean(value);
+          }
+        } else {
+          acc[key] = value;
+        }
       }
       return acc;
     }, {});
-    const mapType = mapArray.reduce((acc, pair) => {
-      const key = pair["0"].value;
+    const mapType = sortedEntries.reduce((acc, pair) => {
+      const key = String(pair["0"].value);
       const keyTypeHint = convertStellarTypeToScValType(pair["0"].type);
       const valueTypeHint = convertStellarTypeToScValType(pair["1"].type);
       acc[key] = [
@@ -998,13 +1086,44 @@ function convertObjectToMap(mapArray) {
 }
 
 // src/transform/parsers/scval-converter.ts
-import { nativeToScVal as nativeToScVal4 } from "@stellar/stellar-sdk";
-import { isEnumValue } from "@openzeppelin/ui-builder-types";
+import { nativeToScVal as nativeToScVal4, xdr as xdr6 } from "@stellar/stellar-sdk";
+import { isEnumValue as isEnumValue2 } from "@openzeppelin/ui-builder-types";
+
+// src/utils/stellar-types.ts
+var PRIMITIVE_STELLAR_TYPES = /* @__PURE__ */ new Set([
+  "Bool",
+  "ScString",
+  "ScSymbol",
+  "Address",
+  "Bytes",
+  "U8",
+  "U16",
+  "U32",
+  "U64",
+  "U128",
+  "U256",
+  "I8",
+  "I16",
+  "I32",
+  "I64",
+  "I128",
+  "I256"
+]);
+function isPrimitiveParamType(type) {
+  return PRIMITIVE_STELLAR_TYPES.has(type);
+}
 
 // src/transform/parsers/struct-parser.ts
-import { nativeToScVal as nativeToScVal3 } from "@stellar/stellar-sdk";
+import { nativeToScVal as nativeToScVal3, xdr as xdr5 } from "@stellar/stellar-sdk";
+import { isEnumValue } from "@openzeppelin/ui-builder-types";
 import { isPlainObject, logger as logger8 } from "@openzeppelin/ui-builder-utils";
 var SYSTEM_LOG_TAG5 = "StructParser";
+function isTupleStructSchema(schema) {
+  if (!schema?.components || schema.components.length === 0) {
+    return false;
+  }
+  return schema.components.every((component, index) => component.name === index.toString());
+}
 function needsParsing(value, fieldType) {
   if ((fieldType === "Bytes" || fieldType.startsWith("BytesN<")) && value instanceof Uint8Array) {
     return false;
@@ -1029,7 +1148,23 @@ function needsParsing(value, fieldType) {
   }
   return false;
 }
-function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerValue) {
+function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerValue, convertToScVal) {
+  if (isTupleStructSchema(paramSchema) && paramSchema && convertToScVal) {
+    const tupleValues = paramSchema.components.map((component, index) => {
+      const key = component.name ?? index.toString();
+      let elementValue = structObj[key];
+      if (typeof elementValue === "undefined") {
+        throw new Error(
+          `Missing tuple value for "${key}" in struct type "${parameterType}". Received: ${JSON.stringify(structObj)}`
+        );
+      }
+      if (typeof elementValue === "string" && isLikelyEnumType(component.type)) {
+        elementValue = { tag: elementValue };
+      }
+      return convertToScVal(elementValue, component.type, component, parseInnerValue);
+    });
+    return xdr5.ScVal.scvVec(tupleValues);
+  }
   const convertedValue = {};
   const typeHints = {};
   for (const [fieldName, fieldValue] of Object.entries(structObj)) {
@@ -1047,6 +1182,9 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
       } else {
         parsedValue = fieldValue;
       }
+      if (typeof parsedValue === "string" && isLikelyEnumType(fieldType)) {
+        parsedValue = { tag: parsedValue };
+      }
       if (fieldType.startsWith("Map<") && Array.isArray(parsedValue)) {
         const mapTypeMatch = fieldType.match(/Map<(.+),\s*(.+)>$/);
         const mapKeyType = mapTypeMatch ? mapTypeMatch[1] : "ScSymbol";
@@ -1068,10 +1206,21 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
         convertedValue[fieldName] = mapObject;
         typeHints[fieldName] = ["symbol", mapTypeHints];
       } else {
-        convertedValue[fieldName] = parsedValue;
-        const scValType = convertStellarTypeToScValType(fieldType);
-        if (scValType !== "map-special") {
-          typeHints[fieldName] = ["symbol", Array.isArray(scValType) ? scValType[0] : scValType];
+        if (convertToScVal && (fieldType.startsWith("Vec<") || isEnumValue(parsedValue))) {
+          const fieldSchema = paramSchema?.components?.find((c) => c.name === fieldName);
+          convertedValue[fieldName] = convertToScVal(
+            parsedValue,
+            fieldType,
+            fieldSchema,
+            parseInnerValue
+          );
+          typeHints[fieldName] = ["symbol", "scval"];
+        } else {
+          convertedValue[fieldName] = parsedValue;
+          const scValType = convertStellarTypeToScValType(fieldType);
+          if (scValType !== "map-special") {
+            typeHints[fieldName] = ["symbol", Array.isArray(scValType) ? scValType[0] : scValType];
+          }
         }
       }
     } else {
@@ -1085,7 +1234,40 @@ function convertStructToScVal(structObj, parameterType, paramSchema, parseInnerV
     convertedValue,
     typeHints
   });
-  const scVal = nativeToScVal3(convertedValue, { type: typeHints });
+  const hasEnumFields = paramSchema?.components?.some((comp) => {
+    const fieldValue = convertedValue[comp.name];
+    return isEnumValue(fieldValue);
+  });
+  let scVal;
+  if (hasEnumFields && convertToScVal && paramSchema?.components) {
+    const mapEntries = [];
+    for (const fieldSchema of paramSchema.components) {
+      const fieldName = fieldSchema.name;
+      const fieldValue = convertedValue[fieldName];
+      const keyScVal = nativeToScVal3(fieldName, { type: "symbol" });
+      let valueScVal;
+      if (isEnumValue(fieldValue)) {
+        valueScVal = convertToScVal(fieldValue, fieldSchema.type, fieldSchema, parseInnerValue);
+      } else {
+        const fieldTypeHint = typeHints[fieldName];
+        if (fieldTypeHint && Array.isArray(fieldTypeHint) && fieldTypeHint.length > 1) {
+          valueScVal = nativeToScVal3(fieldValue, { type: fieldTypeHint[1] });
+        } else {
+          valueScVal = nativeToScVal3(fieldValue);
+        }
+      }
+      mapEntries.push(
+        new xdr5.ScMapEntry({
+          key: keyScVal,
+          val: valueScVal
+        })
+      );
+    }
+    const sortedMapEntries = mapEntries.sort((a, b) => compareScValsByXdr(a.key(), b.key()));
+    scVal = xdr5.ScVal.scvMap(sortedMapEntries);
+  } else {
+    scVal = nativeToScVal3(convertedValue, { type: typeHints });
+  }
   logger8.debug(SYSTEM_LOG_TAG5, "convertStructToScVal generated ScVal:", {
     parameterType,
     scValType: scVal.switch().name,
@@ -1112,16 +1294,95 @@ function isStructType2(value, parameterType) {
 function valueToScVal(value, parameterType, paramSchema, parseInnerValue) {
   const parseValue = parseInnerValue || ((val) => val);
   const genericInfo = parseGenericType(parameterType);
+  const isTypedWrapper = (v) => !!v && typeof v === "object" && "type" in v && "value" in v;
+  const enumMetadata = paramSchema?.enumMetadata;
+  const possibleEnumValue = typeof value === "string" && (enumMetadata || isLikelyEnumType(parameterType)) ? { tag: value } : value;
   if (!genericInfo) {
-    if (isEnumValue(value) || typeof value === "object" && value !== null && "enum" in value) {
-      return convertEnumToScVal(value);
+    if (enumMetadata && enumMetadata.variants.every((v) => v.type === "integer")) {
+      let numericValue;
+      if (typeof value === "string") {
+        const byName = enumMetadata.variants.find((v) => v.name === value);
+        numericValue = byName?.value ?? Number(value);
+      } else if (typeof value === "number") {
+        numericValue = value;
+      } else if (isEnumValue2(value)) {
+        const byTag = enumMetadata.variants.find((v) => v.name === value.tag);
+        numericValue = byTag?.value;
+      }
+      if (numericValue === void 0 || Number.isNaN(numericValue)) {
+        const validNames = enumMetadata.variants.map((v) => v.name).join(", ");
+        throw new Error(
+          `Invalid integer enum value for ${parameterType}: ${String(value)}. Expected one of: ${validNames}`
+        );
+      }
+      return nativeToScVal4(numericValue, { type: "u32" });
+    }
+    if (isTypedWrapper(possibleEnumValue)) {
+      const wrapped = possibleEnumValue;
+      const parsed = parsePrimitive(wrapped.value, wrapped.type);
+      const finalVal = parsed !== null ? parsed : wrapped.value;
+      const scValType2 = convertStellarTypeToScValType(wrapped.type);
+      const typeHint2 = Array.isArray(scValType2) ? scValType2[0] : scValType2;
+      return nativeToScVal4(finalVal, { type: typeHint2 });
+    }
+    if (isEnumValue2(possibleEnumValue) || typeof possibleEnumValue === "object" && possibleEnumValue !== null && "enum" in possibleEnumValue) {
+      const enumValue = possibleEnumValue;
+      if ("enum" in enumValue && typeof enumValue.enum === "number") {
+        return nativeToScVal4(enumValue.enum, { type: "u32" });
+      }
+      const tagSymbol = nativeToScVal4(enumValue.tag, { type: "symbol" });
+      if (!enumValue.values || enumValue.values.length === 0) {
+        return xdr6.ScVal.scvVec([tagSymbol]);
+      }
+      const payloadValues = enumValue.values;
+      let payloadScVals;
+      let variant;
+      if (enumMetadata) {
+        variant = enumMetadata.variants.find((variantEntry) => variantEntry.name === enumValue.tag);
+        if (!variant || !variant.payloadTypes) {
+          return convertEnumToScVal(enumValue);
+        }
+        const payloadTypes = variant.payloadTypes;
+        const payloadComponents = variant.payloadComponents;
+        payloadScVals = payloadTypes.map((payloadType, index) => {
+          const payloadSchema = payloadComponents?.[index] ? {
+            name: `payload_${index}`,
+            type: payloadType,
+            components: payloadComponents[index]
+          } : { name: `payload_${index}`, type: payloadType };
+          const val = payloadValues[index];
+          return valueToScVal(val, payloadType, payloadSchema, parseValue);
+        });
+      } else {
+        return convertEnumToScVal(enumValue);
+      }
+      if (variant?.isSingleTuplePayload) {
+        const tuplePayloadVec = xdr6.ScVal.scvVec(payloadScVals);
+        return xdr6.ScVal.scvVec([tagSymbol, tuplePayloadVec]);
+      }
+      return xdr6.ScVal.scvVec([tagSymbol, ...payloadScVals]);
+    }
+    if (Array.isArray(possibleEnumValue) && paramSchema?.components && paramSchema.components.length) {
+      if (possibleEnumValue.length !== paramSchema.components.length) {
+        throw new Error(
+          `Tuple-struct value length (${possibleEnumValue.length}) does not match schema components (${paramSchema.components.length}) for type ${parameterType}`
+        );
+      }
+      return convertStructToScVal(
+        possibleEnumValue,
+        parameterType,
+        paramSchema,
+        parseValue,
+        (innerValue, innerType, innerSchema) => valueToScVal(innerValue, innerType, innerSchema, parseInnerValue)
+      );
     }
-    if (isStructType2(value, parameterType)) {
+    if (!isPrimitiveParamType(parameterType) && isStructType2(value, parameterType)) {
       return convertStructToScVal(
         value,
         parameterType,
         paramSchema,
-        parseValue
+        parseValue,
+        (innerValue, innerType, innerSchema) => valueToScVal(innerValue, innerType, innerSchema, parseInnerValue)
       );
     }
     if (parameterType === "Bool" || parameterType === "Bytes") {
@@ -1151,15 +1412,30 @@ function valueToScVal(value, parameterType, paramSchema, parseInnerValue) {
     case "Vec": {
       const innerType = parameters[0];
       if (Array.isArray(value)) {
-        const convertedElements = value.map((element) => valueToScVal(element, innerType));
+        let elementSchema;
+        if (enumMetadata) {
+          elementSchema = {
+            name: "element",
+            type: innerType,
+            enumMetadata
+          };
+        } else if (paramSchema?.components) {
+          elementSchema = {
+            name: "element",
+            type: innerType,
+            components: paramSchema.components
+          };
+        }
+        const convertedElements = value.map(
+          (element) => valueToScVal(element, innerType, elementSchema, parseValue)
+        );
         return nativeToScVal4(convertedElements);
       }
       return nativeToScVal4(value);
     }
     case "Map": {
       if (Array.isArray(value)) {
-        const convertedValue = {};
-        const typeHints = {};
+        const mapEntries = [];
         value.forEach(
           (entry) => {
             if (typeof entry !== "object" || entry === null || !entry[0] || !entry[1] || typeof entry[0].value === "undefined" || typeof entry[1].value === "undefined") {
@@ -1175,26 +1451,74 @@ function valueToScVal(value, parameterType, paramSchema, parseInnerValue) {
             if (valuePrimitive !== null) {
               processedValue = valuePrimitive;
             }
-            const keyString = typeof processedKey === "string" ? processedKey : String(processedKey);
-            convertedValue[keyString] = processedValue;
             const keyScValType = convertStellarTypeToScValType(entry[0].type);
+            const keyTypeHint = Array.isArray(keyScValType) ? keyScValType[0] : keyScValType;
+            const keyScVal = nativeToScVal4(processedKey, { type: keyTypeHint });
             const valueScValType = convertStellarTypeToScValType(entry[1].type);
-            typeHints[keyString] = [
-              Array.isArray(keyScValType) ? keyScValType[0] : keyScValType,
-              Array.isArray(valueScValType) ? valueScValType[0] : valueScValType
-            ];
+            const valueTypeHint = Array.isArray(valueScValType) ? valueScValType[0] : valueScValType;
+            const valueScVal = nativeToScVal4(processedValue, { type: valueTypeHint });
+            mapEntries.push(
+              new xdr6.ScMapEntry({
+                key: keyScVal,
+                val: valueScVal
+              })
+            );
           }
         );
-        return nativeToScVal4(convertedValue, { type: typeHints });
+        const sortedMapEntries = mapEntries.sort((a, b) => compareScValsByXdr(a.key(), b.key()));
+        return xdr6.ScVal.scvMap(sortedMapEntries);
       }
       return nativeToScVal4(value);
     }
+    case "Tuple": {
+      if (!paramSchema?.components || paramSchema.components.length === 0) {
+        throw new Error(
+          `Tuple parameter "${paramSchema?.name ?? "unknown"}" is missing component metadata`
+        );
+      }
+      const tupleComponents = paramSchema.components;
+      const tupleValues = [];
+      tupleComponents.forEach((component, index) => {
+        const key = component.name ?? `item_${index}`;
+        let elementValue;
+        if (Array.isArray(value)) {
+          elementValue = value[index];
+        } else if (value && typeof value === "object") {
+          elementValue = value[key];
+        }
+        if (typeof elementValue === "undefined") {
+          const expectedTypes = tupleComponents.map((c) => c.type).join(", ");
+          throw new Error(
+            `Missing tuple value for "${key}" in parameter "${paramSchema.name ?? "unknown"}". Expected ${tupleComponents.length} values of types [${expectedTypes}] but received: ${JSON.stringify(value)}`
+          );
+        }
+        if (typeof elementValue === "string" && isLikelyEnumType(component.type)) {
+          elementValue = { tag: elementValue };
+        }
+        tupleValues.push(valueToScVal(elementValue, component.type, component, parseInnerValue));
+      });
+      return xdr6.ScVal.scvVec(tupleValues);
+    }
     case "Option": {
       const innerType = parameters[0];
       if (value === null || value === void 0) {
         return nativeToScVal4(null);
       } else {
-        return valueToScVal(value, innerType);
+        let innerSchema;
+        if (enumMetadata) {
+          innerSchema = {
+            name: "inner",
+            type: innerType,
+            ...{ enumMetadata }
+          };
+        } else if (paramSchema?.components) {
+          innerSchema = {
+            name: "inner",
+            type: innerType,
+            components: paramSchema.components
+          };
+        }
+        return valueToScVal(value, innerType, innerSchema, parseInnerValue);
       }
     }
     case "Result": {
@@ -1237,12 +1561,15 @@ function parseStellarInput(value, parameterType) {
       const result = parseGeneric(value, parameterType, parseStellarInput);
       return result;
     }
-    if (isEnumValue2(value) && isLikelyEnumType(parameterType)) {
+    if (isEnumValue3(value) && isLikelyEnumType(parameterType)) {
       return value;
     }
     if (isPlainObject2(value)) {
       return value;
     }
+    if (Array.isArray(value)) {
+      return value;
+    }
     if (typeof value === "string" || typeof value === "number") {
       return value;
     }
@@ -3681,11 +4008,69 @@ function getStellarCompatibleFieldTypes(parameterType) {
 
 // src/mapping/field-generator.ts
 import { startCase } from "lodash";
-import { getDefaultValueForType, logger as logger25 } from "@openzeppelin/ui-builder-utils";
+import {
+  enhanceNumericValidation,
+  getDefaultValueForType,
+  logger as logger25
+} from "@openzeppelin/ui-builder-utils";
 
 // src/mapping/enum-metadata.ts
 import { xdr as xdr11 } from "@stellar/stellar-sdk";
 import { logger as logger24 } from "@openzeppelin/ui-builder-utils";
+
+// src/mapping/tuple-components.ts
+function buildTupleComponents(parameterType, specEntries) {
+  const tupleElements = extractTupleTypes(parameterType);
+  if (!tupleElements || tupleElements.length === 0) {
+    return null;
+  }
+  return tupleElements.map((elementType, index) => {
+    let nestedComponents;
+    if (specEntries && isStructType(specEntries, elementType)) {
+      const structFields = extractStructFields(specEntries, elementType);
+      if (structFields && structFields.length > 0) {
+        nestedComponents = structFields;
+      }
+    } else if (elementType.startsWith("Tuple<")) {
+      const tupleStruct = buildTupleComponents(elementType, specEntries);
+      if (tupleStruct && tupleStruct.length > 0) {
+        nestedComponents = tupleStruct;
+      }
+    }
+    return {
+      name: `item_${index}`,
+      type: elementType,
+      displayName: `Value ${index + 1} (${elementType})`,
+      ...nestedComponents && { components: nestedComponents }
+    };
+  });
+}
+
+// src/mapping/enum-metadata.ts
+function flattenPayloadType(payloadType, entries, flattenedTypes, flattenedComponents) {
+  if (payloadType.startsWith("Tuple<")) {
+    const tupleComponents = buildTupleComponents(payloadType, entries);
+    if (tupleComponents && tupleComponents.length > 0) {
+      tupleComponents.forEach((component) => {
+        flattenedTypes.push(component.type);
+        if (isStructType(entries, component.type)) {
+          flattenedComponents.push(extractStructFields(entries, component.type) ?? void 0);
+        } else {
+          flattenedComponents.push(component.components);
+        }
+      });
+    } else {
+      flattenedTypes.push(payloadType);
+      flattenedComponents.push(void 0);
+    }
+  } else if (isStructType(entries, payloadType)) {
+    flattenedTypes.push(payloadType);
+    flattenedComponents.push(extractStructFields(entries, payloadType) ?? void 0);
+  } else {
+    flattenedTypes.push(payloadType);
+    flattenedComponents.push(void 0);
+  }
+}
 function extractEnumVariants(entries, enumName) {
   try {
     const entry = entries.find((e) => {
@@ -3714,11 +4099,29 @@ function extractEnumVariants(entries, enumName) {
           });
         } else if (caseKind.value === xdr11.ScSpecUdtUnionCaseV0Kind.scSpecUdtUnionCaseTupleV0().value) {
           const tupleCase = caseEntry.tupleCase();
-          const payloadTypes = tupleCase.type().map((typeDef) => extractSorobanTypeFromScSpec(typeDef));
+          const rawPayloadTypes = tupleCase.type().map((typeDef) => extractSorobanTypeFromScSpec(typeDef));
+          const isSingleTuplePayload = rawPayloadTypes.length === 1 && rawPayloadTypes[0].startsWith("Tuple<");
+          const flattenedPayloadTypes = [];
+          const flattenedPayloadComponents = [];
+          for (const payloadType of rawPayloadTypes) {
+            flattenPayloadType(
+              payloadType,
+              entries,
+              flattenedPayloadTypes,
+              flattenedPayloadComponents
+            );
+          }
           variants.push({
             name: tupleCase.name().toString(),
             type: "tuple",
-            payloadTypes
+            payloadTypes: flattenedPayloadTypes,
+            ...flattenedPayloadComponents.some(
+              (components) => components && components.length > 0
+            ) && {
+              payloadComponents: flattenedPayloadComponents
+            },
+            // Store metadata about whether this needs tuple wrapping during serialization
+            ...isSingleTuplePayload && { isSingleTuplePayload: true }
           });
           isUnitOnly = false;
         }
@@ -3779,6 +4182,14 @@ function isEnumType(entries, typeName) {
 function getDefaultValidationForType() {
   return { required: true };
 }
+var STELLAR_NUMERIC_BOUNDS = {
+  U8: { min: 0, max: 255 },
+  U16: { min: 0, max: 65535 },
+  U32: { min: 0, max: 4294967295 },
+  I8: { min: -128, max: 127 },
+  I16: { min: -32768, max: 32767 },
+  I32: { min: -2147483648, max: 2147483647 }
+};
 function generateStellarDefaultField(parameter, contractSchema) {
   const specEntries = contractSchema?.metadata?.specEntries;
   const fieldType = mapStellarParameterTypeToFieldType(parameter.type);
@@ -3792,8 +4203,10 @@ function generateStellarDefaultField(parameter, contractSchema) {
   let structComponents = null;
   let finalFieldType = fieldType;
   let options;
-  if (isLikelyEnumType(parameter.type)) {
-    if (specEntries && isEnumType(specEntries, parameter.type)) {
+  const enumDetectedBySpec = !!(specEntries && isEnumType(specEntries, parameter.type));
+  const enumDetectedHeuristic = isLikelyEnumType(parameter.type);
+  if (enumDetectedBySpec || enumDetectedHeuristic) {
+    if (enumDetectedBySpec) {
       enumMetadata = extractEnumVariants(specEntries, parameter.type);
       if (enumMetadata) {
         if (enumMetadata.isUnitOnly) {
@@ -3822,6 +4235,12 @@ function generateStellarDefaultField(parameter, contractSchema) {
       structComponents = structFields;
     }
   }
+  if (!structComponents) {
+    const tupleComponents = buildTupleComponents(parameter.type, specEntries);
+    if (tupleComponents && tupleComponents.length > 0) {
+      structComponents = tupleComponents;
+    }
+  }
   const baseField = {
     id: `field-${Math.random().toString(36).substring(2, 9)}`,
     name: parameter.name || parameter.type,
@@ -3835,6 +4254,11 @@ function generateStellarDefaultField(parameter, contractSchema) {
     width: "full",
     options
   };
+  baseField.validation = enhanceNumericValidation(
+    baseField.validation,
+    parameter.type,
+    STELLAR_NUMERIC_BOUNDS
+  );
   if (isBytesNType(parameter.type)) {
     const sizeMatch = parameter.type.match(/^BytesN<(\d+)>$/);
     const maxBytes = sizeMatch ? Number.parseInt(sizeMatch[1], 10) : void 0;
@@ -3845,17 +4269,50 @@ function generateStellarDefaultField(parameter, contractSchema) {
       };
     }
   }
-  if (fieldType === "array") {
+  if (fieldType === "array" || fieldType === "array-object") {
     const elementType = extractVecElementType(parameter.type);
     if (elementType) {
       const elementFieldType = mapStellarParameterTypeToFieldType(elementType);
+      let elementEnumMetadata;
+      let elementComponents;
+      let finalElementFieldType = elementFieldType;
+      if (isLikelyEnumType(elementType)) {
+        if (specEntries && isEnumType(specEntries, elementType)) {
+          elementEnumMetadata = extractEnumVariants(specEntries, elementType) ?? void 0;
+          if (elementEnumMetadata) {
+            finalElementFieldType = elementEnumMetadata.isUnitOnly ? "select" : "enum";
+          }
+        }
+      }
+      if (specEntries && isStructType(specEntries, elementType)) {
+        const structFields = extractStructFields(specEntries, elementType);
+        if (structFields && structFields.length > 0) {
+          elementComponents = structFields;
+          finalElementFieldType = "object";
+        }
+      }
+      if (fieldType === "array-object" && parameter.components) {
+        elementComponents = parameter.components;
+        finalElementFieldType = "object";
+      }
+      let elementValidation = { required: true };
+      elementValidation = enhanceNumericValidation(
+        elementValidation,
+        elementType,
+        STELLAR_NUMERIC_BOUNDS
+      );
       const arrayField = {
         ...baseField,
-        elementType: elementFieldType,
+        type: "array",
+        // Always use 'array' as the field type
+        elementType: finalElementFieldType,
         elementFieldConfig: {
-          type: elementFieldType,
-          validation: { required: true },
-          placeholder: `Enter ${elementType}`
+          type: finalElementFieldType,
+          validation: elementValidation,
+          placeholder: `Enter ${elementType}`,
+          originalParameterType: elementType,
+          ...elementEnumMetadata && { enumMetadata: elementEnumMetadata },
+          ...elementComponents && { components: elementComponents }
         }
       };
       return arrayField;
@@ -3873,13 +4330,21 @@ function generateStellarDefaultField(parameter, contractSchema) {
           valueType: valueFieldType,
           keyFieldConfig: {
             type: keyFieldType,
-            validation: { required: true },
+            validation: enhanceNumericValidation(
+              { required: true },
+              mapTypes.keyType,
+              STELLAR_NUMERIC_BOUNDS
+            ),
             placeholder: `Enter ${mapTypes.keyType}`,
             originalParameterType: mapTypes.keyType
           },
           valueFieldConfig: {
             type: valueFieldType,
-            validation: { required: true },
+            validation: enhanceNumericValidation(
+              { required: true },
+              mapTypes.valueType,
+              STELLAR_NUMERIC_BOUNDS
+            ),
             placeholder: `Enter ${mapTypes.valueType}`,
             originalParameterType: mapTypes.valueType
           }
@@ -3915,8 +4380,36 @@ 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 { isEnumValue as isEnumValue4 } from "@openzeppelin/ui-builder-types";
 import { logger as logger26 } from "@openzeppelin/ui-builder-utils";
+function enrichParameterWithEnumMetadata(param, specEntries) {
+  if (!specEntries) {
+    return param;
+  }
+  const enriched = { ...param };
+  if (isLikelyEnumType(param.type) && isEnumType(specEntries, param.type)) {
+    const enumMetadata = extractEnumVariants(specEntries, param.type);
+    if (enumMetadata) {
+      enriched.enumMetadata = enumMetadata;
+    }
+  }
+  const vecMatch = param.type.match(/^Vec<([^>]+)>$/);
+  if (vecMatch) {
+    const elementType = vecMatch[1];
+    if (isLikelyEnumType(elementType) && isEnumType(specEntries, elementType)) {
+      const enumMetadata = extractEnumVariants(specEntries, elementType);
+      if (enumMetadata) {
+        enriched.enumMetadata = enumMetadata;
+      }
+    }
+  }
+  if (enriched.components && enriched.components.length > 0) {
+    enriched.components = enriched.components.map(
+      (component) => enrichParameterWithEnumMetadata(component, specEntries)
+    );
+  }
+  return enriched;
+}
 function formatStellarTransactionData(contractSchema, functionId, submittedInputs, fields) {
   logger26.info(
     "formatStellarTransactionData",
@@ -3956,10 +4449,10 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
   }
   const transformedArgs = expectedArgs.map((param, index) => {
     let valueToParse = orderedRawValues[index];
-    if (isEnumValue3(valueToParse)) {
-      const specEntries = contractSchema.metadata?.specEntries;
-      if (specEntries && isEnumType(specEntries, param.type)) {
-        const enumMetadata = extractEnumVariants(specEntries, param.type);
+    if (isEnumValue4(valueToParse)) {
+      const specEntries2 = contractSchema.metadata?.specEntries;
+      if (specEntries2 && isEnumType(specEntries2, param.type)) {
+        const enumMetadata = extractEnumVariants(specEntries2, param.type);
         const enumValue = valueToParse;
         if (enumMetadata && enumValue.values) {
           const selectedVariant = enumMetadata.variants.find((v) => v.name === enumValue.tag);
@@ -3967,14 +4460,15 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
             const processedValues = enumValue.values.map(
               (rawValue, payloadIndex) => {
                 const expectedType = selectedVariant.payloadTypes[payloadIndex];
-                if (expectedType) {
-                  const processedValue = parseStellarInput(rawValue, expectedType);
-                  return {
-                    type: expectedType,
-                    value: processedValue
-                  };
+                if (!expectedType) {
+                  return rawValue;
+                }
+                const processedValue = parseStellarInput(rawValue, expectedType);
+                const isPrimitivePayload = isPrimitiveParamType(expectedType) || isBytesNType(expectedType);
+                if (isPrimitivePayload) {
+                  return { type: expectedType, value: processedValue };
                 }
-                return rawValue;
+                return processedValue;
               }
             );
             valueToParse = { ...enumValue, values: processedValues };
@@ -3995,14 +4489,64 @@ function formatStellarTransactionData(contractSchema, functionId, submittedInput
   } catch {
     throw new Error("Contract address is missing or invalid in the provided schema.");
   }
+  const fieldByName = /* @__PURE__ */ new Map();
+  fields.forEach((field) => fieldByName.set(field.name, field));
+  const specEntries = contractSchema.metadata?.specEntries;
+  const argSchemaWithComponents = functionDetails.inputs.map((param) => {
+    const field = fieldByName.get(param.name);
+    const enhanced = { ...param };
+    if (param.components && param.components.length > 0) {
+      enhanced.components = param.components;
+    } else if (field?.components && field.components.length > 0) {
+      enhanced.components = field.components;
+    }
+    if (field?.enumMetadata) {
+      enhanced.enumMetadata = field.enumMetadata;
+    }
+    if (param.type.startsWith("Vec<") && field?.elementFieldConfig) {
+      if (field.elementFieldConfig.enumMetadata) {
+        enhanced.enumMetadata = field.elementFieldConfig.enumMetadata;
+      }
+      if (field.elementFieldConfig.components) {
+        enhanced.components = field.elementFieldConfig.components;
+      }
+    }
+    if (enhanced.components && enhanced.components.length > 0) {
+      enhanced.components = enhanced.components.map((component) => {
+        const nestedFieldName = `${param.name}.${component.name}`;
+        const nestedField = fieldByName.get(nestedFieldName);
+        if (nestedField) {
+          const enrichedComponent = { ...component };
+          if (nestedField.enumMetadata) {
+            enrichedComponent.enumMetadata = nestedField.enumMetadata;
+          }
+          if (nestedField.components) {
+            enrichedComponent.components = nestedField.components;
+          }
+          if (component.type.startsWith("Vec<") && nestedField.elementFieldConfig) {
+            if (nestedField.elementFieldConfig.enumMetadata) {
+              enrichedComponent.enumMetadata = nestedField.elementFieldConfig.enumMetadata;
+            }
+            if (nestedField.elementFieldConfig.components) {
+              enrichedComponent.components = nestedField.elementFieldConfig.components;
+            }
+          }
+          return enrichedComponent;
+        }
+        return component;
+      });
+    }
+    const finalEnhanced = enrichParameterWithEnumMetadata(enhanced, specEntries);
+    return finalEnhanced;
+  });
   const stellarTransactionData = {
     contractAddress: contractSchema.address,
     functionName: functionDetails.name,
     args: transformedArgs,
     argTypes: functionDetails.inputs.map((param) => param.type),
     // Include parameter types for ScVal conversion
-    argSchema: functionDetails.inputs,
-    // Include full parameter schema with struct field definitions
+    argSchema: argSchemaWithComponents,
+    // Include full parameter schema with struct/tuple field definitions
     transactionOptions: {
       // Add any Stellar-specific transaction options here
       // For example: fee, timeout, memo, etc.