Skip to main content

Try it Live

Run Address examples in the interactive playground
View the complete executable example at playground/src/examples/primitives/address/validate.ts.

    ​
    Validation Rules

    With 0x prefix:
    • Exactly 42 characters total
    • First 2 characters: 0x
    • Next 40 characters: valid hex (0-9, a-f, A-F)
    Without 0x prefix:
    • Exactly 40 characters total
    • All characters: valid hex (0-9, a-f, A-F)
    Case insensitive:
    • Accepts lowercase, uppercase, or mixed case
    • Does not validate EIP-55 checksum

    ​
    Use Cases

    ​
    Input Validation

    Validate user input before parsing: 
    import { Address } from 'tevm'

function parseUserAddress(input: string): Address {
  if (!Address.isValid(input)) {
    throw new Error('Invalid address format')
  }

  return Address(input)
}

// Safe to parse
try {
  const addr = parseUserAddress(userInput)
  console.log('Address:', addr.toHex())
} catch (e) {
  console.error('Invalid input:', e.message)
}

    ​
    Form Validation

    Validate addresses in forms: 
    import { Address } from 'tevm'

function validateAddressField(value: string): string | null {
  if (!value) {
    return 'Address is required'
  }

  if (!Address.isValid(value)) {
    return 'Invalid address format. Expected 40 hex characters with optional 0x prefix.'
  }

  return null // Valid
}

// React example
function AddressInput() {
  const [value, setValue] = useState('')
  const [error, setError] = useState<string | null>(null)

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const input = e.target.value
    setValue(input)
    setError(validateAddressField(input))
  }

  return (
    <div>
      <input
        type="text"
        value={value}
        onChange={handleChange}
        placeholder="0x..."
      />
      {error && <span className="error">{error}</span>}
    </div>
  )
}

    ​
    API Input Validation

    Validate addresses in API requests: 
    import { Address } from 'tevm'

app.post('/transfer', (req, res) => {
  const { to, amount } = req.body

  if (!Address.isValid(to)) {
    return res.status(400).json({
      error: 'Invalid recipient address'
    })
  }

  const recipient = Address(to)
  // Process transfer...
})

    ​
    Defensive Programming

    Check before processing: 
    import { Address } from 'tevm'

function processAddresses(addresses: string[]) {
  const valid = addresses.filter(Address.isValid)
  const invalid = addresses.filter(addr => !Address.isValid(addr))

  console.log(`Valid: ${valid.length}, Invalid: ${invalid.length}`)

  return valid.map(Address.fromHex)
}

    ​
    Common Invalid Inputs

    import { Address } from 'tevm'

// Too short
console.log(Address.isValid("0x742d35"))                    // false

// Too long
console.log(Address.isValid("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3XX")) // false

// Invalid characters
console.log(Address.isValid("0xGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG")) // false
console.log(Address.isValid("0x742d35Cc 6634C0532925a3b844Bc9e7595f251e3")) // false (space)

// Wrong prefix
console.log(Address.isValid("x742d35Cc6634C0532925a3b844Bc9e7595f251e3"))  // false

// Empty
console.log(Address.isValid(""))                            // false
console.log(Address.isValid("0x"))                          // false

    ​
    Validation Without Checksum

    isValid() does NOT validate EIP-55 checksums: 
    import { Address } from 'tevm'

// Valid format, but wrong checksum
const addr = "0x742d35cc6634c0532925a3b844bc9e7595f51e3e"  // all lowercase
console.log(Address.isValid(addr))          // true (format valid)
console.log(Address.isValidChecksum(addr))  // false (checksum incorrect)

// To validate checksum, use isValidChecksum()
if (Address.isValid(addr) && Address.isValidChecksum(addr)) {
  console.log('Valid address with correct checksum')
}

    ​
    Performance

    Fast validation: Checks length and character ranges only. No parsing: Does not allocate or parse hex values. Use before parsing: Validate first to avoid exceptions: 
    import { Address } from 'tevm'

// Efficient: validate before parsing
if (Address.isValid(input)) {
  const addr = Address(input)
  // Process addr...
}

// Inefficient: use try/catch for validation
try {
  const addr = Address(input)
  // Process addr...
} catch (e) {
  // Handle invalid format
}

    ​
    Type Narrowing

    Use as type guard in TypeScript: 
    import { Address } from 'tevm'

function processInput(input: string | Address) {
  if (typeof input === 'string') {
    if (!Address.isValid(input)) {
      throw new Error('Invalid address string')
    }
    return Address(input)
  }

  return input // Already an Address
}

    ​
    See Also