@openzeppelin/ui-builder-adapter-evm 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/ui-builder-adapter-evm",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": false,
   "description": "EVM Adapter for UI Builder",
   "keywords": [
@@ -43,10 +43,10 @@
     "lodash": "^4.17.21",
     "lucide-react": "^0.510.0",
     "react-hook-form": "^7.62.0",
-    "@openzeppelin/ui-builder-react-core": "^0.15.0",
-    "@openzeppelin/ui-builder-types": "^0.15.0",
-    "@openzeppelin/ui-builder-ui": "^0.15.0",
-    "@openzeppelin/ui-builder-utils": "^0.15.0"
+    "@openzeppelin/ui-builder-react-core": "^0.16.0",
+    "@openzeppelin/ui-builder-types": "^0.16.0",
+    "@openzeppelin/ui-builder-ui": "^0.16.0",
+    "@openzeppelin/ui-builder-utils": "^0.16.0"
   },
   "devDependencies": {
     "@rainbow-me/rainbowkit": "^2.2.8",

package/src/mapping/__tests__/field-generator.test.ts

@@ -20,9 +20,35 @@ describe('EVM Field Generator', () => {
 
       expect(field.type).toBe('number');
       expect(field.validation.required).toBe(true);
+      expect(field.validation.min).toBe(0);
+      expect(field.validation.max).toBe(4_294_967_295);
       expect(field.validation.pattern).toBeUndefined();
     });
 
+    it('should apply numeric bounds for uint8', () => {
+      const param = createParam('uint8', 'byte');
+      const field = generateEvmDefaultField(param);
+
+      expect(field.validation.min).toBe(0);
+      expect(field.validation.max).toBe(255);
+    });
+
+    it('should apply numeric bounds for int8', () => {
+      const param = createParam('int8', 'signedByte');
+      const field = generateEvmDefaultField(param);
+
+      expect(field.validation.min).toBe(-128);
+      expect(field.validation.max).toBe(127);
+    });
+
+    it('should apply numeric bounds for int32', () => {
+      const param = createParam('int32', 'signedInt');
+      const field = generateEvmDefaultField(param);
+
+      expect(field.validation.min).toBe(-2_147_483_648);
+      expect(field.validation.max).toBe(2_147_483_647);
+    });
+
     it('should generate a bigint field for uint128', () => {
       const param = createParam('uint128', 'amount');
       const field = generateEvmDefaultField(param);
@@ -86,6 +112,17 @@ describe('EVM Field Generator', () => {
       // Integer validation is handled by BigIntField component internally
     });
 
+    it('should apply numeric bounds to array element fields', () => {
+      const param = createParam('uint32[]', 'counts');
+      const field = generateEvmDefaultField(param);
+
+      expect(field.type).toBe('array');
+      expect(field.elementFieldConfig).toBeDefined();
+      expect(field.elementFieldConfig!.validation).toBeDefined();
+      expect(field.elementFieldConfig!.validation!.min).toBe(0);
+      expect(field.elementFieldConfig!.validation!.max).toBe(4_294_967_295);
+    });
+
     it('should include proper field metadata', () => {
       const param = createParam('uint256', 'value');
       const field = generateEvmDefaultField(param);

package/src/mapping/field-generator.ts

@@ -7,7 +7,11 @@ import type {
   FormFieldType,
   FunctionParameter,
 } from '@openzeppelin/ui-builder-types';
-import { getDefaultValueForType } from '@openzeppelin/ui-builder-utils';
+import {
+  enhanceNumericValidation,
+  getDefaultValueForType,
+  type NumericBoundsMap,
+} from '@openzeppelin/ui-builder-utils';
 
 import { mapEvmParamTypeToFieldType } from './type-mapper';
 
@@ -33,6 +37,23 @@ function getDefaultValidation(): FieldValidation {
   return { required: true };
 }
 
+/**
+ * EVM numeric type bounds.
+ * Maps EVM type names to their min/max value constraints.
+ * Note: uint64, uint128, uint256, int64, int128, int256 exceed JavaScript's Number.MAX_SAFE_INTEGER
+ * and are handled via BigInt fields, so bounds are not applied here.
+ */
+const EVM_NUMERIC_BOUNDS: NumericBoundsMap = {
+  uint: { min: 0 },
+  uint8: { min: 0, max: 255 },
+  uint16: { min: 0, max: 65_535 },
+  uint32: { min: 0, max: 4_294_967_295 },
+  int: {},
+  int8: { min: -128, max: 127 },
+  int16: { min: -32_768, max: 32_767 },
+  int32: { min: -2_147_483_648, max: 2_147_483_647 },
+};
+
 /**
  * Generate default field configuration for an EVM function parameter.
  */
@@ -49,7 +70,11 @@ export function generateEvmDefaultField<T extends FieldType = FieldType>(
     placeholder: `Enter ${parameter.displayName || parameter.name || parameter.type}`,
     helperText: parameter.description || '',
     defaultValue: getDefaultValueForType(fieldType) as FieldValue<T>,
-    validation: getDefaultValidation(),
+    validation: enhanceNumericValidation(
+      getDefaultValidation(),
+      parameter.type,
+      EVM_NUMERIC_BOUNDS
+    ),
     width: 'full',
   };
 
@@ -65,7 +90,11 @@ export function generateEvmDefaultField<T extends FieldType = FieldType>(
         elementType: elementFieldType,
         elementFieldConfig: {
           type: elementFieldType,
-          validation: getDefaultValidation(),
+          validation: enhanceNumericValidation(
+            getDefaultValidation(),
+            elementType,
+            EVM_NUMERIC_BOUNDS
+          ),
           placeholder: `Enter ${elementType}`,
         },
       };

package/src/wallet/implementation/wagmi-implementation.ts

@@ -99,6 +99,7 @@ export class WagmiWalletImplementation {
   private unsubscribe?: ReturnType<typeof watchAccount>;
   private initialized: boolean = false;
   private walletConnectProjectId?: string;
+  private rpcConfigUnsubscribe?: () => void;
 
   /**
    * Constructs the WagmiWalletImplementation.
@@ -121,9 +122,50 @@ export class WagmiWalletImplementation {
       LOG_SYSTEM,
       'WagmiWalletImplementation instance initialized (Wagmi config creation deferred).'
     );
+    // Subscribe to RPC configuration changes to invalidate cached config
+    this.setupRpcConfigListener();
     // No config created here by default anymore.
   }
 
+  /**
+   * Sets up a listener for RPC configuration changes to invalidate the cached Wagmi config
+   * when user changes RPC settings.
+   */
+  private setupRpcConfigListener(): void {
+    // Import dynamically to avoid circular dependencies
+    import('@openzeppelin/ui-builder-utils')
+      .then(({ userRpcConfigService }) => {
+        // Subscribe to all RPC config changes
+        this.rpcConfigUnsubscribe = userRpcConfigService.subscribe('*', (event) => {
+          if (event.type === 'rpc-config-changed' || event.type === 'rpc-config-cleared') {
+            logger.info(
+              LOG_SYSTEM,
+              `RPC config changed for network ${event.networkId}. Invalidating cached Wagmi config.`
+            );
+            // Invalidate the cached config to force recreation with new RPC settings
+            this.defaultInstanceConfig = null;
+          }
+        });
+      })
+      .catch((error) => {
+        logger.error(LOG_SYSTEM, 'Failed to setup RPC config listener:', error);
+      });
+  }
+
+  /**
+   * Cleanup method to unsubscribe from RPC config changes
+   */
+  public cleanup(): void {
+    if (this.rpcConfigUnsubscribe) {
+      this.rpcConfigUnsubscribe();
+      this.rpcConfigUnsubscribe = undefined;
+    }
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+    }
+  }
+
   /**
    * Sets the externally determined, currently active WagmiConfig instance.
    * This is typically called by EvmUiKitManager after it has resolved the appropriate
@@ -333,8 +375,12 @@ export class WagmiWalletImplementation {
       );
     }
 
-    // Always rebuild default config to reflect latest RPC overrides/user settings
-    this.defaultInstanceConfig = this.createDefaultConfig();
+    // Reuse existing default config if available, only create if needed
+    // This ensures wallet connection state is preserved across network switches
+    // Config is automatically invalidated when RPC settings change via setupRpcConfigListener()
+    if (!this.defaultInstanceConfig) {
+      this.defaultInstanceConfig = this.createDefaultConfig();
+    }
     return this.defaultInstanceConfig;
   }