@openzeppelin/ui-builder-adapter-evm 1.2.0 → 1.4.0

package/src/mapping/__tests__/type-mapper.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { getEvmCompatibleFieldTypes, mapEvmParamTypeToFieldType } from '../type-mapper';
-
-describe('EVM Type Mapper', () => {
-  describe('mapEvmParamTypeToFieldType', () => {
-    it('should map small integer types to number field', () => {
-      expect(mapEvmParamTypeToFieldType('uint')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('uint8')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('uint16')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('uint32')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('int')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('int8')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('int16')).toBe('number');
-      expect(mapEvmParamTypeToFieldType('int32')).toBe('number');
-    });
-
-    it('should map 64-bit and larger integer types to bigint field to avoid precision loss', () => {
-      // These types can hold values larger than JavaScript's Number.MAX_SAFE_INTEGER (2^53-1)
-      expect(mapEvmParamTypeToFieldType('uint64')).toBe('bigint');
-      expect(mapEvmParamTypeToFieldType('uint128')).toBe('bigint');
-      expect(mapEvmParamTypeToFieldType('uint256')).toBe('bigint');
-      expect(mapEvmParamTypeToFieldType('int64')).toBe('bigint');
-      expect(mapEvmParamTypeToFieldType('int128')).toBe('bigint');
-      expect(mapEvmParamTypeToFieldType('int256')).toBe('bigint');
-    });
-
-    it('should map address to blockchain-address field', () => {
-      expect(mapEvmParamTypeToFieldType('address')).toBe('blockchain-address');
-    });
-
-    it('should map bool to checkbox field', () => {
-      expect(mapEvmParamTypeToFieldType('bool')).toBe('checkbox');
-    });
-
-    it('should map string to text field', () => {
-      expect(mapEvmParamTypeToFieldType('string')).toBe('text');
-    });
-
-    it('should map bytes types to text/textarea fields', () => {
-      expect(mapEvmParamTypeToFieldType('bytes')).toBe('textarea');
-      expect(mapEvmParamTypeToFieldType('bytes32')).toBe('text');
-    });
-
-    it('should map array types correctly', () => {
-      expect(mapEvmParamTypeToFieldType('uint256[]')).toBe('array');
-      expect(mapEvmParamTypeToFieldType('address[]')).toBe('array');
-      expect(mapEvmParamTypeToFieldType('string[]')).toBe('array');
-    });
-
-    it('should map tuple types to object', () => {
-      expect(mapEvmParamTypeToFieldType('tuple')).toBe('object');
-    });
-
-    it('should map array of tuples to array-object', () => {
-      expect(mapEvmParamTypeToFieldType('tuple[]')).toBe('array-object');
-      expect(mapEvmParamTypeToFieldType('tuple[5]')).toBe('array-object');
-    });
-
-    it('should default to text for unknown types', () => {
-      expect(mapEvmParamTypeToFieldType('unknown')).toBe('text');
-      expect(mapEvmParamTypeToFieldType('custom')).toBe('text');
-    });
-  });
-
-  describe('getEvmCompatibleFieldTypes', () => {
-    it('should return bigint as first compatible type for 64-bit and larger unsigned integers', () => {
-      // Verify uint64
-      const compatibleTypesUint64 = getEvmCompatibleFieldTypes('uint64');
-      expect(compatibleTypesUint64[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesUint64).toContain('number');
-      expect(compatibleTypesUint64).toContain('amount');
-      expect(compatibleTypesUint64).toContain('text');
-
-      // Verify uint128
-      const compatibleTypesUint128 = getEvmCompatibleFieldTypes('uint128');
-      expect(compatibleTypesUint128[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesUint128).toContain('number');
-      expect(compatibleTypesUint128).toContain('amount');
-      expect(compatibleTypesUint128).toContain('text');
-
-      // Verify uint256
-      const compatibleTypesUint256 = getEvmCompatibleFieldTypes('uint256');
-      expect(compatibleTypesUint256[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesUint256).toContain('number');
-      expect(compatibleTypesUint256).toContain('amount');
-      expect(compatibleTypesUint256).toContain('text');
-    });
-
-    it('should return bigint as first compatible type for 64-bit and larger signed integers', () => {
-      // Verify int64
-      const compatibleTypesInt64 = getEvmCompatibleFieldTypes('int64');
-      expect(compatibleTypesInt64[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesInt64).toContain('number');
-      expect(compatibleTypesInt64).toContain('text');
-
-      // Verify int128
-      const compatibleTypesInt128 = getEvmCompatibleFieldTypes('int128');
-      expect(compatibleTypesInt128[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesInt128).toContain('number');
-      expect(compatibleTypesInt128).toContain('text');
-
-      // Verify int256
-      const compatibleTypesInt256 = getEvmCompatibleFieldTypes('int256');
-      expect(compatibleTypesInt256[0]).toBe('bigint'); // First (recommended) type
-      expect(compatibleTypesInt256).toContain('number');
-      expect(compatibleTypesInt256).toContain('text');
-    });
-
-    it('should return number as first compatible type for small integers', () => {
-      // Small integers that fit within JavaScript Number precision
-      const compatibleTypes = getEvmCompatibleFieldTypes('uint32');
-      expect(compatibleTypes[0]).toBe('number'); // First (recommended) type
-      expect(compatibleTypes).toContain('amount');
-      expect(compatibleTypes).toContain('text');
-    });
-
-    it('should return compatible field types for address', () => {
-      const compatibleTypes = getEvmCompatibleFieldTypes('address');
-      expect(compatibleTypes[0]).toBe('blockchain-address'); // First (recommended) type
-      expect(compatibleTypes).toContain('text');
-    });
-
-    it('should return compatible field types for bool', () => {
-      const compatibleTypes = getEvmCompatibleFieldTypes('bool');
-      expect(compatibleTypes[0]).toBe('checkbox'); // First (recommended) type
-      expect(compatibleTypes).toContain('select');
-      expect(compatibleTypes).toContain('radio');
-      expect(compatibleTypes).toContain('text');
-    });
-
-    it('should return compatible field types for arrays', () => {
-      const compatibleTypes = getEvmCompatibleFieldTypes('uint256[]');
-      expect(compatibleTypes[0]).toBe('array'); // First (recommended) type
-      expect(compatibleTypes).toContain('textarea');
-      expect(compatibleTypes).toContain('text');
-    });
-  });
-});

package/src/mapping/constants.ts

@@ -1,57 +0,0 @@
-import type { FieldType, TypeMappingInfo } from '@openzeppelin/ui-types';
-
-/**
- * EVM-specific type mapping to default form field types.
- *
- * Note: Large integer types (uint128, uint256, int128, int256) are mapped to 'bigint'
- * instead of 'number' to avoid JavaScript's Number precision limitations.
- * JavaScript's Number type can only safely represent integers up to 2^53 - 1,
- * but these types can hold much larger values. The BigIntField component stores values
- * as strings and the EVM adapter handles BigInt conversion automatically.
- */
-export const EVM_TYPE_TO_FIELD_TYPE: Record<string, FieldType> = {
-  address: 'blockchain-address',
-  string: 'text',
-  uint: 'number',
-  uint8: 'number',
-  uint16: 'number',
-  uint32: 'number',
-  uint64: 'bigint',
-  uint128: 'bigint',
-  uint256: 'bigint',
-  int: 'number',
-  int8: 'number',
-  int16: 'number',
-  int32: 'number',
-  int64: 'bigint',
-  int128: 'bigint',
-  int256: 'bigint',
-  bool: 'checkbox',
-  bytes: 'textarea',
-  bytes32: 'text',
-};
-
-/**
- * EVM dynamic type patterns handled through pattern matching.
- */
-const EVM_DYNAMIC_PATTERNS: TypeMappingInfo['dynamicPatterns'] = [
-  { name: 'array', syntax: 'T[]', mapsTo: 'array', description: 'Dynamic array of primitives' },
-  { name: 'fixed-array', syntax: 'T[N]', mapsTo: 'array', description: 'Fixed-size array' },
-  {
-    name: 'tuple-array',
-    syntax: 'tuple[]',
-    mapsTo: 'array-object',
-    description: 'Array of structs',
-  },
-  { name: 'tuple', syntax: 'tuple', mapsTo: 'object', description: 'Struct/tuple type' },
-];
-
-/**
- * Returns complete type mapping information for EVM.
- */
-export function getEvmTypeMappingInfo(): TypeMappingInfo {
-  return {
-    primitives: { ...EVM_TYPE_TO_FIELD_TYPE },
-    dynamicPatterns: EVM_DYNAMIC_PATTERNS,
-  };
-}

package/src/mapping/field-generator.ts

@@ -1,115 +0,0 @@
-import { startCase } from 'lodash';
-
-import type {
-  FieldType,
-  FieldValidation,
-  FieldValue,
-  FormFieldType,
-  FunctionParameter,
-} from '@openzeppelin/ui-types';
-import {
-  enhanceNumericValidation,
-  getDefaultValueForType,
-  type NumericBoundsMap,
-} from '@openzeppelin/ui-utils';
-
-import { mapEvmParamTypeToFieldType } from './type-mapper';
-
-/**
- * Extracts the inner type from an EVM array type.
- * @param parameterType - The parameter type (e.g., 'uint32[]', 'address[]')
- * @returns The inner type (e.g., 'uint32', 'address') or null if not an array type
- */
-function extractArrayElementType(parameterType: string): string | null {
-  // Handle array types like uint32[], address[], bytes32[]
-  const arrayMatch = parameterType.match(/^(.+)\[\d*\]$/);
-  if (arrayMatch) {
-    return arrayMatch[1];
-  }
-  return null;
-}
-
-/**
- * Get default validation rules for a parameter.
- * Field-specific validation is handled by the field components themselves.
- */
-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.
- */
-export function generateEvmDefaultField<T extends FieldType = FieldType>(
-  parameter: FunctionParameter
-): FormFieldType<T> {
-  const fieldType = mapEvmParamTypeToFieldType(parameter.type) as T;
-
-  const baseField: FormFieldType<T> = {
-    id: `field-${Math.random().toString(36).substring(2, 9)}`,
-    name: parameter.name || parameter.type, // Use type if name missing
-    label: startCase(parameter.displayName || parameter.name || parameter.type),
-    type: fieldType,
-    placeholder: `Enter ${parameter.displayName || parameter.name || parameter.type}`,
-    helperText: parameter.description || '',
-    defaultValue: getDefaultValueForType(fieldType) as FieldValue<T>,
-    validation: enhanceNumericValidation(
-      getDefaultValidation(),
-      parameter.type,
-      EVM_NUMERIC_BOUNDS
-    ),
-    width: 'full',
-  };
-
-  // For array types, provide element type information
-  if (fieldType === 'array') {
-    const elementType = extractArrayElementType(parameter.type);
-    if (elementType) {
-      const elementFieldType = mapEvmParamTypeToFieldType(elementType);
-
-      // Add array-specific properties
-      const arrayField = {
-        ...baseField,
-        elementType: elementFieldType,
-        elementFieldConfig: {
-          type: elementFieldType,
-          validation: enhanceNumericValidation(
-            getDefaultValidation(),
-            elementType,
-            EVM_NUMERIC_BOUNDS
-          ),
-          placeholder: `Enter ${elementType}`,
-        },
-      };
-      return arrayField;
-    }
-  }
-
-  // Preserve components for object and array-object types
-  if (parameter.components && (fieldType === 'object' || fieldType === 'array-object')) {
-    const result = {
-      ...baseField,
-      components: parameter.components,
-    };
-    return result;
-  }
-
-  return baseField;
-}

package/src/mapping/index.ts

@@ -1,4 +0,0 @@
-// Barrel file for mapping module
-export * from './constants';
-export * from './type-mapper';
-export * from './field-generator';

package/src/mapping/type-mapper.ts

@@ -1,80 +0,0 @@
-import type { FieldType } from '@openzeppelin/ui-types';
-
-import { EVM_TYPE_TO_FIELD_TYPE } from './constants';
-
-/**
- * Map a blockchain-specific parameter type to a default form field type.
- * @param parameterType The blockchain parameter type (e.g., 'uint256', 'address', 'tuple')
- * @returns The appropriate default form field type (e.g., 'number', 'blockchain-address', 'object')
- */
-export function mapEvmParamTypeToFieldType(parameterType: string): FieldType {
-  // Check if this is an array of tuples/objects
-  if (parameterType.match(/^tuple\[\d*\]$/)) {
-    return 'array-object';
-  }
-
-  // Check if this is an array type (ends with [] or [number])
-  if (parameterType.match(/\[\d*\]$/)) {
-    return 'array';
-  }
-
-  // Extract the base type from array types (e.g., uint256[] -> uint256)
-  const baseType = parameterType.replace(/\[\d*\]/g, '');
-
-  // Handle tuples (structs) - use object for composite types
-  if (baseType.startsWith('tuple')) {
-    return 'object';
-  }
-
-  // Map common EVM types to appropriate field types
-  return EVM_TYPE_TO_FIELD_TYPE[baseType] || 'text'; // Default to 'text'
-}
-
-/**
- * Get field types compatible with a specific parameter type.
- * @param parameterType The blockchain parameter type.
- * @returns Array of compatible form field types.
- */
-export function getEvmCompatibleFieldTypes(parameterType: string): FieldType[] {
-  // Handle array of objects
-  if (parameterType.match(/^tuple\[\d*\]$/)) {
-    return ['array-object', 'textarea', 'text'];
-  }
-
-  // Handle array types - allow array field or fallback to textarea/text
-  if (parameterType.match(/\[\d*\]$/)) {
-    return ['array', 'textarea', 'text'];
-  }
-
-  const baseType = parameterType.replace(/\[\d*\]/g, '');
-
-  // Handle tuples/objects
-  if (baseType.startsWith('tuple')) {
-    return ['object', 'textarea', 'text'];
-  }
-
-  // Define compatibility map for base types
-  const compatibilityMap: Record<string, FieldType[]> = {
-    address: ['blockchain-address', 'text'],
-    uint: ['number', 'amount', 'text'],
-    uint8: ['number', 'amount', 'text'],
-    uint16: ['number', 'amount', 'text'],
-    uint32: ['number', 'amount', 'text'],
-    uint64: ['bigint', 'number', 'amount', 'text'],
-    uint128: ['bigint', 'number', 'amount', 'text'],
-    uint256: ['bigint', 'number', 'amount', 'text'],
-    int: ['number', 'text'],
-    int8: ['number', 'text'],
-    int16: ['number', 'text'],
-    int32: ['number', 'text'],
-    int64: ['bigint', 'number', 'text'],
-    int128: ['bigint', 'number', 'text'],
-    int256: ['bigint', 'number', 'text'],
-    bool: ['checkbox', 'select', 'radio', 'text'],
-    string: ['text', 'textarea', 'email', 'password'],
-    bytes: ['textarea', 'text'],
-    bytes32: ['text', 'textarea'],
-  };
-
-  return compatibilityMap[baseType] || ['text']; // Default to 'text'
-}