feat(adapter-stellar): Contract Loading and Interpretation (#134)

* Version Packages (#132)

* Version Packages

* chore: update export versions and test snapshots

---------

Co-authored-by: oz-release-app[bot] <205211949+oz-release-app[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* fix(adapter-stellar): update rpc urls

* fix(adapter-stellar): add missing sorobanRpcUrl config property

* feat(adapter-stellar): implement Contract Loading and Interpretation

- Implement loadStellarContract and loadStellarContractWithMetadata functions
- Add Stellar SDK integration for contract address validation and RPC communication
- Create extractFunctionsFromSpec for parsing Soroban contract specifications
- Add comprehensive function classification (view/writable function detection)
- Implement metadata tracking with source, contract name, and timestamps
- Add getStellarExplorerAddressUrl with correct /contract path for Soroban contracts
- Remove verificationStatus from Stellar metadata (not applicable to Soroban)
- Add URL encoding for explorer links for security
- Update ContractDefinitionSourceIndicator copy to be chain-agnostic
- Add transformStellarSpecToSchema placeholder with documentation for future work
- Comprehensive error handling for invalid addresses and network failures
- Display formatting following EVM adapter patterns

* fix(ui): snapshot pre-append and fallback setValue to fix add-item with default 0 in ArrayField (#139)

* fix: resolve array validation issues with zero values and redundant logic (#137)

* fix(adapter-evm): clean up redundant ternary in array field validation

# Conflicts:
#	packages/adapter-evm/src/mapping/field-generator.ts

* fix(ui): allow zero values in ArrayField required validation

* fix(adapter-evm): use consistent validation for array elements

Apply getDefaultValidationForType to array element validation instead of
hardcoded { required: true } for better consistency and to ensure arrays
of addresses get proper validation.

* chore(builder): restore version 0.7.1 packages from orphaned changeset release (#141)

Co-authored-by: oz-release-app[bot] <205211949+oz-release-app[bot]@users.noreply.github.com>

* fix(ci): prevent duplicate production deployments with concurrency control (#142)

- Add concurrency group 'production-deployment' to docker-prod.yaml
- Enable cancel-in-progress to stop redundant deployments
- Resolves issue where multiple package releases trigger simultaneous production deployments
- Only one deployment will run at a time, saving resources and avoiding conflicts

* fix: stabilize arrays and autosave for hardcoded values (#143)

* fix(ui): stabilize array ops across contexts

* fix(builder): trigger autosave on hardcoded array add/remove and input edits

* fix(builder): consolidate autosave dependencies into a single composite key

* chore(release): add changeset for array persistence and autosave fixes

* Version Packages (#144)

* Version Packages

* chore: update export versions and test snapshots

---------

Co-authored-by: oz-release-app[bot] <205211949+oz-release-app[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* feat(ui): add BytesField component with validation support (#145)

* feat(ui): add BytesField component with validation support

Implements a specialized BytesField component for blockchain bytes data:
- Supports hex and base64 validation using validator.js library
- EVM compatibility with configurable 0x prefix support
- Built-in byte length validation and format detection
- Comprehensive unit tests with 46 test cases
- Integration with existing form field architecture
- Chain-agnostic validation utilities in utils package

# Conflicts:
#	packages/utils/src/index.ts
#	pnpm-lock.yaml

* fix(builder): remove duplicate text property in fieldTypeCategories

Fixes TypeScript build error caused by duplicate 'text' property in the
fieldTypeCategories object. Consolidated the text field types into a single
property including the new 'bytes' field type.

* fix(utils): use Web API atob() instead of Node.js Buffer for browser compatibility

Replace Buffer.from() with atob() in base64 byte size calculation to avoid
potential issues in browser environments. The Web API atob() is natively
supported in all modern browsers and provides the same functionality for
calculating byte sizes from base64 encoded data.

* perf(ui): optimize BytesField formatting performance

Remove formatValue from onChange handler to avoid expensive string processing
on every keystroke. Formatting now only occurs on blur when the user finishes
typing, providing better performance for long hex strings while maintaining
good user experience.

* fix(utils): fix byteSize calculation in bytesValidation for invalid hex strings

Move byteSize calculation after even-length validation check to prevent
returning incorrect byte sizes (like 1.5) for odd-length hex strings.
Now byteSize is only calculated after confirming the hex string is valid.

Also fix JSDoc formatting lint issue.

* ci: fix file permissions and optimize pre-commit hook (#146)

* fix(ci): remove executable permissions from scripts and add file mode check to pre-commit hook

- Remove executable permissions from export-app.cjs to satisfy GitHub Actions check
- Add file mode validation to pre-commit hook to prevent future violations
- Ensures commits are blocked when disallowed executable files are detected

* ci(ci): add auto-fix for file permissions in pre-commit hook

- Modified check-file-modes.cjs to automatically fix executable permissions
- Enhanced pre-commit hook to auto-fix instead of failing
- Improves developer experience by eliminating manual fixes

* perf(ci): optimize pre-commit hook by running fast checks first

- Reorder pre-commit operations to run file permissions check before expensive formatting/linting
- Fail fast on file permission issues before spending time on formatting
- Add descriptive messaging to indicate when expensive operations are running
- Improves developer experience by reducing wasted time on failed commits

* fix(ci): prevent command injection in file permissions script

- Replace unsafe shell command interpolation with spawnSync
- Use proper argument array instead of string concatenation
- Prevents command injection if file paths contain special characters
- Fix help message to use pnpm instead of npm for consistency
- Maintains all existing functionality while improving security

* fix(adapter-evm): resolve @wagmi/core version conflicts causing CI failures (#148)

* fix(adapter-evm): resolve @wagmi/core version conflicts causing CI failures

* test(builder): update export snapshots after dependency changes

* feat(adapter-stellar): Complete Type Mapping & Data Transformation with Comprehensive Enhancements (#136)

* fix(adapter-evm): remove broken address validation from field configs

- Remove custom validation function that never worked due to type mismatch
- Was checking 'blockchain-address' but receiving 'address' parameter type
- Remove unused isValidEvmAddress import from field-generator
- Simplify validation to only basic serializable rules
- Address validation still works through adapter.isValidAddress() method
- Fixes IndexedDB serialization issues with custom validation functions

* feat(adapter-stellar): type Mapping and Data Transformation with comprehensive enhancements

- Implemented mapStellarParameterTypeToFieldType with support for all Soroban types
- Created generateStellarDefaultField following EVM adapter patterns
- Added formatStellarFunctionResult with comprehensive ScVal support
- Built complete type mapping system with STELLAR_TYPE_TO_FIELD_TYPE constants

🛡️ **Bulletproof Type Coverage Validation:**
- Added exhaustive unit tests covering all 26 StellarSdk.xdr.ScSpecType values
- Implemented fail-fast runtime detection with detailed error reporting
- Created type mapping completeness validator with coverage reporting
- Added automated SDK type detection script with postinstall hook integration

🔍 **Missing Type Discovery & Fixes:**
- Fixed scSpecTypeBytesN handling for fixed-size byte arrays (BytesN<32> hashes)
- Added scSpecTypeMuxedAddress support for multiplexed addresses
- Enhanced type extraction with comprehensive switch statement coverage

🏗️ **Validation Architecture Improvements:**
- Removed non-serializable custom validation functions from field configs
- Established adapter.isValidAddress() as single source of truth for validation
- Implemented clean separation between serializable config and runtime validation
- Fixed related EVM adapter validation bug during architectural alignment

🔧 **Utility Function Enhancements:**
- Added isSerializableObject utility for blockchain-specific object detection
- Refactored utilities to utils/formatting.ts for better code organization
- Enhanced byte array formatting with proper 0x hex prefixing
- Improved BigInt handling in JSON serialization

📋 **Comprehensive Test Suite:**
- 34 type mapping tests covering all scenarios and edge cases
- 14 field generation tests with validation and fallback scenarios
- 33 output formatting tests covering all ScVal types and error handling
- Type coverage tests ensuring 100% ScSpecType support

✅ **Quality & Maintenance:**
- All tests pass with comprehensive coverage
- Full TypeScript compliance with proper typing
- Linting compliance and code quality standards
- Enhanced error handling and logging throughout

* fix(adapter-stellar): resolve failing tests with proper SDK mocking

- Fix loader test by implementing partial mock for @stellar/stellar-sdk using importOriginal
- Update test expectations for function IDs to match parameter type changes
- Enhance complete-type-coverage test to dynamically handle SDK version changes
- All 191 Stellar adapter tests now passing

* chore(adapter-stellar): formatting

* fix(builder): enable Stellar ecosystem by default and update tests

* refactor(adapter-stellar): address PR review feedback

- Improve ScVal detection in output formatter using instanceof check
- Move environment utilities to utils package for reusability
- Update loader to use shared environment utilities
- Fix unused error parameter in type coverage validator
- Keep 1-second polling interval (important for responsiveness)

* feat(adapter-stellar): complete Query and Transaction Execution (#149)

* fix(adapter-stellar): update testnet RPC URL to resolve DNS resolution error

* fix(adapter-evm): clean up redundant ternary in array field validation

* fix(ui): allow zero values in ArrayField required validation

* feat(adapter-stellar): implement core query and transaction execution

- Implement queryStellarViewFunction with proper ScVal type hints for reliable contract simulation
- Add formatStellarTransactionData with argTypes field for transaction execution
- Integrate convertStellarTypeToScValType utility for consistent type conversion
- Update adapter.ts with networkConfig passing and loadContract wrapper
- Add DataUrl type mapping support following Laboratory patterns

* feat(adapter-stellar): implement transaction execution strategies

- Refactor signAndBroadcastStellarTransaction to follow Strategy Pattern architecture
- Create ExecutionStrategy interface for consistent transaction handling
- Implement EoaExecutionStrategy for direct wallet-based execution
- Add RelayerExecutionStrategy placeholder for future gasless transactions
- Update sender.ts to act as orchestrator selecting appropriate strategy
- Integrate getStellarWalletConnectionStatus and signTransaction from wallet module

* feat(adapter-stellar): add comprehensive Soroban input parsing utilities

- Create input-parsing.ts with Laboratory-inspired parsing for complex Soroban types
- Add type guards for primitives, enums, maps, objects, arrays, and tuples
- Implement ScVal conversion utilities for all Soroban data structures
- Add detectBytesEncoding to shared utils package for cross-adapter reuse
- Support Maps, Enums, Vectors, nested structures, and type validation
- Modularize utilities for improved maintainability and reusability

* test(adapter-stellar): add comprehensive test coverage for Task 5

- Create formatter.test.ts with extensive transaction data formatting tests
- Add comprehensive input-parser.test.ts covering all parsing scenarios:
  * Primitive types (String, U128, Bool, Bytes, Address)
  * Complex types (Vec, Option, custom structs)
  * Advanced parsing (Maps, Enums, Tuples, nested structures)
  * valueToScVal and getScValsFromArgs functionality
  * Error handling and edge cases
- Update test expectations for argTypes field and Uint8Array Bytes format
- Ensure all 33 test cases pass for robust input parsing validation

* fix(adapter-stellar): move Buffer polyfill to adapter package

- Move Buffer polyfill from main builder app to Stellar adapter entry point
- Ensures Buffer is only loaded when Stellar adapter is used
- Clean architecture preventing adapter-specific polyfills from polluting main app
- Type-safe implementation using globalThis type assertion

* fix(adapter-stellar): resolve Vec<T> transaction errors and consolidate generic type parsing

* fix(ui): snapshot pre-append and fallback setValue to fix add-item with default 0 in ArrayField

* fix(adapter-evm): strengthen transaction status callback type safety

- Update execution strategy interface to use TxStatus instead of string
- Prevent future issues with invalid status strings in transaction callbacks
- Improve type safety and IDE support for transaction status updates

* fix(adapter-stellar): strengthen transaction status callback type safety

- Update execution strategy interface to use TxStatus instead of string
- Prevent future issues with invalid status strings in transaction callbacks
- Improve type safety and IDE support for transaction status updates

* feat(ui): add chain-agnostic enum field support

- Add EnumValue interface for cross-chain enum representation
- Implement EnumField UI component with variant picker and payload inputs
- Enhance FormGenerator and FormSchemaFactory with enum metadata support
- Update DynamicFormField to render enum fields with payload field delegation
- Add enum field type to field registry and form field types
- Implement auto-save serialization for enum fields
- Update base adapter interface to support enum metadata
- Maintain backward compatibility with existing field types

* chore(ui): add changeset for enum field support

- Document new chain-agnostic enum field functionality
- Includes EnumValue interface and EnumField component
- Notes enhanced form generation and auto-save capabilities

* feat(ui): add enum field support to form utilities

- Add enum field transform support in formUtils.ts
- Add enum field type option in fieldTypeUtils.ts
- Include enum in selection category for UI builder
- Ensures enum fields work with form transforms and field type selection

* feat(adapter-stellar): implement enum field support for Soroban contracts

Core Implementation:
- Add enum metadata extraction from Stellar contract specEntries
- Implement enum type detection and variant analysis
- Update field generator to handle enum types with metadata
- Enhance input parser to convert EnumValue to ScVal format
- Add comprehensive enum conversion utilities

Field Generation:
- Extract enum variants (unit, tuple, integer) from contract specs
- Generate appropriate field types (select for unit-only, enum for complex)
- Pass enum metadata through form generation pipeline
- Support fallback to select field when no metadata available

Input Processing:
- Parse chain-agnostic EnumValue format to Soroban ScVal
- Handle unit variants, tuple variants with payloads
- Use ScSymbol for enum tags and ScVec for structure
- Integrate with existing input parsing pipeline

Testing & Quality:
- Add comprehensive unit tests for enum metadata extraction
- Add integration tests for end-to-end enum field functionality
- Add transaction formatter tests for enum value handling
- Fix all linting issues and type safety

Contract Schema:
- Add specEntries to contract metadata for enum introspection
- Update contract loader to preserve spec information
- Maintain backward compatibility with existing schemas

* fix(adapter-stellar): resolve enum payload processing for raw UI values

- Add enum payload processing in formatStellarTransactionData to handle raw values from UI
- Convert raw enum payload values to SorobanArgumentValue objects using enum metadata
- Process values through parseStellarInput with correct type information from specEntries
- Add comprehensive test suite with 7 test cases covering various scenarios
- Fix TypeScript linting issues with proper EnumValue type usage
- Maintain backward compatibility and graceful fallbacks for missing metadata

Fixes issue where enum tuple variants with numeric payloads (e.g., Two(u32)) were failing
with HostError: Error(WasmVm, InvalidAction) due to improper ScVal conversion.

* feat(builder): add enum field support for hardcoded values and readOnly state

* feat(ui): add BytesField component with validation support

Implements a specialized BytesField component for blockchain bytes data:
- Supports hex and base64 validation using validator.js library
- EVM compatibility with configurable 0x prefix support
- Built-in byte length validation and format detection
- Comprehensive unit tests with 46 test cases
- Integration with existing form field architecture
- Chain-agnostic validation utilities in utils package

* fix(ui): resolve BytesField readOnly prop inheritance in MapField

- Fix BytesField not being disabled when parent MapField has readOnly=true
- Pass isDisabled: readOnly to getAccessibilityProps to prevent prop override
- Remove duplicate map field render implementation in DynamicFormField
- Ensure readOnly prop properly inherits from parent to child fields

* feat(types): add MapEntry types and form field metadata

- Add comprehensive MapEntry interface in dedicated common/map.ts
- Follow EnumValue pattern with chain-agnostic design and cross-chain examples
- Add type guards: isMapEntry and isMapEntryArray for runtime validation
- Extend FormFieldType with mapMetadata for key/value type configuration
- Update FieldValue type mapping for proper map field typing

* feat(ui): add MapField component for key-value pair inputs

- Implement comprehensive MapField React component with drag-and-drop reordering
- Support dynamic add/remove of key-value entries with proper validation
- Include responsive design with mobile-friendly layout
- Add accessibility features and keyboard navigation support
- Remove unused vitest setup file reference for cleaner configuration

* feat(adapter-stellar): add MapField and BytesField integration

- Update type mapping to use 'map' field type for Stellar Map types
- Add map type extraction and field generation for Map<K,V> parameters
- Update Bytes types to properly map to 'bytes' field type
- Include enhanced field metadata for key/value type configurations
- Add comprehensive tests for new mapping functionality

* feat(utils): register MapField in component registry and add utilities

- Register MapField component in renderer fieldRegistry for form rendering
- Add default value support for 'map' field type in fieldDefaults utility
- Export bytesValidation utilities from utils package index

* feat(builder): integrate MapField in form builder interface

- Add MapField support in FieldBasicSettings for field type selection
- Include 'map' in available field types for form customization
- Update configBuilder to handle MapEntry serialization for auto-save
- Extend FormSchemaFactory and FormGenerator to support map field creation
- Enable map field configuration in builder UI workflow

* fix(adapter-stellar): resolve MapField transaction execution with comprehensive type support

- Convert MapEntry format to Stellar SDK expected format in parseStellarInput
- Add comprehensive type support via recursive parseStellarInput for keys and values
- Use existing isMapEntryArray type guard from types package instead of manual validation
- Handle all Stellar types including primitives, numerics, addresses, complex types
- Clean up comments to use 'Stellar SDK format' instead of tool-specific references
- Ensure proper type conversion with convertStellarTypeToScValType for nativeToScVal compatibility

* fix(react-core): prevent wallet header error by removing global window error hook in WalletConnectionUI per @commitlint.config.js

* fix(adapter-stellar): sync connection from kit so EOA execution sees connected wallet

* refactor(adapter): move wallet interfaces to dedicated directories

- Move wallet connection status interfaces to wallet/types.ts across all adapters
- Create adapter-specific interface extensions (EvmWalletConnectionStatus, etc.)
- Add convertWagmiToEvmStatus utility to eliminate duplication in EVM adapter
- Fix chainId type conversion in EVM execution config validation
- Fix React key generation bug preventing Stellar wallet UI from mounting
- Maintain architectural consistency across EVM, Stellar, and Solana adapters
- All adapters now follow identical wallet directory structure

* refactor(adapter-stellar): complete wallet interface refactoring

- Update adapter to use new implementation manager and return StellarWalletConnectionStatus
- Fix Freighter popup loop by implementing event-driven wallet connection approach
- Add stellarWalletImplementationManager for singleton wallet implementation handling
- Replace aggressive polling with event subscriptions and minimal fallback polling
- Export wallet utilities for proper module organization

* docs(adapter): add wallet interface refactoring changesets

- Add changeset for EVM adapter wallet interface refactoring
- Add changeset for Stellar adapter Freighter popup bug fix and interface refactoring
- Add changeset for Solana adapter wallet interface consistency
- Add changeset for React Core wallet UI mounting fix
- Add changeset for Types package wallet interface enhancement
- Document breaking wallet loop fix and architectural improvements

* refactor(adapter-stellar): modularize parsing into transform/parsers and re-export

* feat(adapter-stellar): extract struct fields from spec and propagate argSchema

* fix(adapter-stellar): replace console.warn with logger; map Map to 'map' and update tests

* feat(ui): add MapField component with hooks and structural validation

* feat(ui): show errors on touch; unify validation helpers; avoid programmatic blur

* refactor(ui): use adapter.generateDefaultField; coerce hardcoded values

feat(builder): propagate field validation to selectors

feat(builder): combine field and execution validation

* fix(utils): use Buffer for base64 size; add isPlainObject and tests

* test(storage): switch default validation mode to onTouched and adjust expectations

* chore(export): make CLI script executable

chore(adapter-stellar,deps): bump @stellar/stellar-sdk to ^14.1.1 and update lockfile

* chore(ui): clean up

* perf(builder): memoize render functions in DynamicFormField to prevent unnecessary re-renders

- Add useCallback memoization for renderPayloadField, renderKeyField, renderValueField
- Move render functions to component level with proper dependency arrays
- Refactor getFieldSpecificProps to accept memoized render functions
- Fix React Hooks rule violations by moving hooks before early returns
- Improves performance for complex form interactions, especially MapField and EnumField

* fix(builder): preserve enum hardcoded values between builder and preview modes

- Add coerceEnumHardcodedValue function to handle EnumValue objects properly
- Add enum case to coerceHardcodedValue switch statement
- Import isEnumValue type guard from types package
- Provide sensible EnumValue defaults for corrupted or missing enum data
- Add enum initialization logic for new hardcoded enum fields
- Follows same clean pattern as existing map/array collection handlers
- Fixes issue where enum hardcoded values were coerced to strings and lost structure

* fix(builder): remove Buffer polyfill usage for true cross-platform compatibility

Remove Buffer polyfill from Stellar adapter and replace all Buffer usage with
native browser APIs (atob/btoa/Uint8Array) across utils and adapter packages.
Add comprehensive bytesConversion utilities with full test coverage.
Fix type errors in input-parsing and test mocks.

* fix(ui): add explicit disabled prop to BytesField for consistency with other field components

* fix(ui): replace unsafe type assertion with proper type guards in validateMapStructure

* fix(adapter-stellar): resolve test failures for generic parser and struct conversion

- Fixed parseGenericType regex to handle empty angle brackets (Vec<>, Map<>, Option<>)
- Changed regex from .+ to .* to match zero or more characters
- Updated struct conversion test to expect current error message format
- All 359 tests now passing successfully

* feat(adapter-stellar): implement query and transaction execution functionality

- Added complete Stellar contract query and transaction execution support
- Enhanced output formatting with comprehensive type handling
- Improved complex and primitive type parsers for better data conversion
- Updated input parsing utilities for robust parameter processing
- Extended address validation test coverage
- Updated export system tests for compatibility
- All tests passing (359/359)

* fix(adapter-stellar): remove remaining Buffer references in output formatter

Remove instanceof Buffer checks in output-formatter.ts and formatting.ts
to fully eliminate Buffer usage and prevent 'Buffer is not defined' errors
in browser environments.

* perf(ui): optimize isDuplicateMapKey to use some() instead of filter().length

* fix(ui): add disabled prop to BytesField Controller for consistent form state management

* docs(builder): add comprehensive JSDoc to coerceHardcodedValue function

* Update packages/utils/src/bytesValidation.ts

Co-authored-by: Copilot <[email protected]>

* fix(ui): improve empty key handling clarity in map validation logic

* fix(ui): improve form field validation consistency and touch handling

- Add missing isTouched parameter to getValidationStateClasses calls in
  EnumField, AmountField, and BooleanField for consistent success styling
- Fix BytesField missing field.onBlur() call to register touched state
  for green success borders on valid fields

---------

Co-authored-by: Copilot <[email protected]>

* fix(adapter-stellar): add cross-platform Buffer compatibility for bytes ScVal output

Handle Buffer objects returned by scValToNative() by safely detecting
and converting them to Uint8Array for cross-platform compatibility.
This fixes test failures while maintaining browser compatibility.

* feat(adapter): improve type safety with specific contract artifact interfaces

Replace generic FormValues with adapter-specific artifact interfaces:
- Add EvmContractArtifacts, StellarContractArtifacts, SolanaContractArtifacts,
  MidnightContractArtifacts interfaces
- Create type guards for runtime validation (isEvmContractArtifacts, etc.)
- Implement validation utilities in utils/artifacts.ts for each adapter
- Update all adapter loadContract methods to use specific types internally
- Maintain backward compatibility with generic ContractAdapter interface
- Add comprehensive unit tests for type guards and validation utilities

This improves type safety, code clarity, and maintainability while preserving
the chain-agnostic architecture. The ContractAdapter interface remains generic
to support various input formats, while internal implementations are type-safe.

* feat(adapter-stellar): implement simulation-based state mutability detection

Replace simple heuristic with Laboratory-style simulation approach that checks
stateChanges.length > 0 to accurately determine function mutability. Refactor
loadStellarContractFromAddress to accept proper StellarNetworkConfig parameter
instead of creating temporary config objects.

* refactor(builder): extract type-specific coercion functions for improved maintainability

* refactor(builder): extract specialized handlers from complex FieldEditor handleUpdate callback

---------

Co-authored-by: oz-release-app[bot] <205211949+oz-release-app[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <[email protected]>

Author: 4 people

.changeset/adapter-evm-wallet-refactor.md

@@ -0,0 +1,11 @@
+---
+'@openzeppelin/contracts-ui-builder-adapter-evm': patch
+---
+
+Refactor wallet interface architecture for consistency
+
+- Move `EvmWalletConnectionStatus` interface to `wallet/types.ts` for better organization
+- Add `convertWagmiToEvmStatus` utility function to eliminate code duplication
+- Fix chainId type conversion in execution config validation to handle both string and number types
+- Update wallet barrel exports to include new types and utilities
+- Maintain structural compatibility with base `WalletConnectionStatus` interface

.changeset/adapter-solana-wallet-refactor.md

@@ -0,0 +1,11 @@
+---
+'@openzeppelin/contracts-ui-builder-adapter-solana': patch
+---
+
+Refactor wallet interface architecture for consistency
+
+- Move `SolanaWalletConnectionStatus` interface to `wallet/types.ts` for better organization
+- Update wallet connection functions to use two-parameter callback signature
+- Maintain structural compatibility with base `WalletConnectionStatus` interface
+- Align wallet directory structure with other adapters for architectural consistency
+- Update barrel exports to include new wallet types

.changeset/adapter-stellar-wallet-refactor.md

@@ -0,0 +1,13 @@
+---
+'@openzeppelin/contracts-ui-builder-adapter-stellar': patch
+---
+
+Fix Freighter wallet popup loop and refactor wallet interface architecture
+
+- **Fix critical bug**: Replace aggressive polling with event-driven wallet connection approach in `StellarWalletUiRoot`
+- **Eliminate infinite Freighter popups** that occurred when clicking wallet connection button
+- Add `stellarWalletImplementationManager` singleton pattern following EVM adapter architecture
+- Update adapter to use new implementation manager and return `StellarWalletConnectionStatus`
+- Move wallet interfaces (`StellarWalletConnectionStatus`, `StellarConnectionStatusListener`) to `wallet/types.ts`
+- Implement event subscriptions with minimal fallback polling (5-minute intervals instead of 1-second)
+- Align wallet directory structure with EVM adapter for architectural consistency

.changeset/clear-trees-buy.md

@@ -0,0 +1,9 @@
+---
+'@openzeppelin/contracts-ui-builder-renderer': minor
+'@openzeppelin/contracts-ui-builder-app': minor
+'@openzeppelin/contracts-ui-builder-types': minor
+'@openzeppelin/contracts-ui-builder-utils': minor
+'@openzeppelin/contracts-ui-builder-ui': minor
+---
+
+support for new BytesField component with validation

.changeset/curly-vans-beg.md

@@ -0,0 +1,5 @@
+---
+'@openzeppelin/contracts-ui-builder-ui': patch
+---
+
+allow zero values in ArrayField required validation

.changeset/lucky-corners-repair.md

@@ -0,0 +1,5 @@
+---
+'@openzeppelin/contracts-ui-builder-adapter-evm': patch
+---
+
+remove broken address validation from field configs

.changeset/polite-words-laugh.md

@@ -0,0 +1,5 @@
+---
+'@openzeppelin/contracts-ui-builder-ui': patch
+---
+
+snapshot pre-append and fallback setValue to fix add-item with default 0 in ArrayField

.changeset/react-core-wallet-ui-fix.md

@@ -0,0 +1,10 @@
+---
+'@openzeppelin/contracts-ui-builder-react-core': patch
+---
+
+Fix wallet UI mounting issue when switching between ecosystems
+
+- Fix React key generation bug in `WalletStateProvider` that prevented Stellar wallet UI from mounting after switching from EVM networks
+- Update key generation to use `${ecosystem}-${networkId}` format for proper component unmounting/mounting
+- Remove unused `lastFullUiKitConfiguration` property from `ExtendedContractAdapter` interface
+- Ensure proper wallet UI reconciliation when switching between different blockchain ecosystems

.changeset/small-books-divide.md

@@ -0,0 +1,5 @@
+---
+'@openzeppelin/contracts-ui-builder-adapter-evm': patch
+---
+
+Update EVM adapter execution strategy interface to use TxStatus instead of string

.changeset/tame-ghosts-lay.md

@@ -0,0 +1,8 @@
+---
+'@openzeppelin/contracts-ui-builder-renderer': minor
+'@openzeppelin/contracts-ui-builder-app': minor
+'@openzeppelin/contracts-ui-builder-types': minor
+'@openzeppelin/contracts-ui-builder-ui': minor
+---
+
+New FormField UI component for enum type handling and representation