Address.isValidChecksum

Validate EIP-55 checksummed address

Try it Live

Run Address examples in the interactive playground

TypeScript - Factory

Address.IsValidChecksum({ keccak256 })

Factory function that creates a checksum validator with explicit crypto dependency.

Parameters:

• deps: { keccak256: (data: Uint8Array) => Uint8Array } - Crypto dependencies

Returns: (str: string) => boolean

Bundle size benefit: Crypto dependencies explicit - only bundled if you import them.

Example:

import { IsValidChecksum } from 'tevm/Address/AddressType'
import { hash as keccak256 } from 'tevm/crypto/Keccak256'

// Create factory with explicit crypto dependency
const isValidChecksum = IsValidChecksum({ keccak256 })

// Validate checksummed addresses
isValidChecksum("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed") // true
isValidChecksum("0x5aaeb6053F3E94C9b9A09f33669435E7Ef1BeAed") // false

C

bool primitives_address_validate_checksum(const char* hex)

Validate EIP-55 checksum in C. Checks if hex string has valid mixed-case checksum.

Parameters:

• hex: const char* - Address hex string (with or without 0x prefix)

Returns: bool - true if checksum is valid

Example:

#include "primitives.h"
#include <stdio.h>

// Valid checksummed addresses
bool valid1 = primitives_address_validate_checksum("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed");
printf("Valid: %d\n", valid1); // 1 (true)

bool valid2 = primitives_address_validate_checksum("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e");
printf("Valid: %d\n", valid2); // 1 (true)

// Invalid checksum (wrong casing)
bool invalid1 = primitives_address_validate_checksum("0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed");
printf("Valid: %d\n", invalid1); // 0 (false)

bool invalid2 = primitives_address_validate_checksum("0x742D35CC6634C0532925A3B844BC9E7595F51E3E");
printf("Valid: %d\n", invalid2); // 0 (false) - wrong case

// All lowercase/uppercase passes (no checksum)
bool lower = primitives_address_validate_checksum("0x742d35cc6634c0532925a3b844bc9e7595f51e3e");
printf("Valid: %d\n", lower); // 1 (true)

bool upper = primitives_address_validate_checksum("0x742D35CC6634C0532925A3B844BC9E7595F51E3E");
printf("Valid: %d\n", upper); // 1 (true)

EIP-55 Rules:

• All lowercase: valid (no checksum to verify)
• All uppercase: valid (no checksum to verify)
• Mixed case: must match keccak256-based checksum

Use Case - Strict Validation:

#include "primitives.h"

int parse_strict_address(const char* input, PrimitivesAddress* out) {
    // Validate checksum first
    if (!primitives_address_validate_checksum(input)) {
        return -1; // Invalid checksum
    }

    // Parse if valid
    return primitives_address_from_hex(input, out);
}

Memory: No allocation - pure validation function.

Defined in: primitives.h:130

EIP-55 Checksum Rules

All lowercase: Valid (no checksum to verify)

Address.isValidChecksum("0x742d35cc6634c0532925a3b844bc9e7595f51e3e") // true

All uppercase: Valid (no checksum to verify)

Address.isValidChecksum("0x742D35CC6634C0532925A3B844BC9E7595F51E3E") // true

Mixed case: Must match keccak256-based checksum

// Correct mixed case
Address.isValidChecksum("0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e") // true

// Incorrect mixed case
Address.isValidChecksum("0x742d35cc6634c0532925a3b844bc9e7595f51e3E") // false

Use Cases

Strict Validation

Require checksummed addresses:

import { Address } from 'tevm'

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

  if (!Address.isValidChecksum(input)) {
    throw new Error('Invalid or missing EIP-55 checksum')
  }

  return Address(input)
}

Warn on Invalid Checksum

Accept but warn about invalid checksums:

import { Address } from 'tevm'

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

  if (!Address.isValidChecksum(input)) {
    console.warn('Address has invalid checksum. Double-check the address.')
  }

  return Address(input)
}

UI Validation

Provide checksum feedback in forms:

import { Address } from 'tevm'

function validateAddressInput(value: string) {
  if (!value) {
    return { valid: false, message: 'Address required' }
  }

  if (!Address.isValid(value)) {
    return { valid: false, message: 'Invalid address format' }
  }

  if (!Address.isValidChecksum(value)) {
    return {
      valid: true,
      warning: 'Invalid checksum. Address may be mistyped.'
    }
  }

  return { valid: true }
}

Accept Lowercase, Return Checksummed

Accept any valid format, return checksummed:

import { Address } from 'tevm'

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

  const addr = Address(input)
  return addr.toChecksummed() // Always return checksummed
}

// All inputs normalized to checksummed
console.log(normalizeAddress("0x742d35cc6634c0532925a3b844bc9e7595f51e3e"))
// "0x742d35Cc6634C0532925a3b844Bc9e7595f51e3e"

Checksum Calculation

The checksum is computed as follows:

1. Convert address to lowercase hex (without 0x)
2. Compute keccak256 hash of lowercase string
3. For each hex character (if letter):
   • If corresponding hash nibble >= 8: uppercase
   • Otherwise: lowercase

Example:

import { Address } from 'tevm'

const lowercase = "0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed"
const addr = Address(lowercase)

// Generate checksummed version
const checksummed = addr.toChecksummed()
console.log(checksummed)
// "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"
//     ^  ^     ^  ^ ^^     ^  ^             ^

// Verify checksum
console.log(Address.isValidChecksum(checksummed)) // true
console.log(Address.isValidChecksum(lowercase))   // true (all lowercase = no checksum)

Common Scenarios

QR Code addresses: Often all uppercase (valid):

const qrCode = "0x742D35CC6634C0532925A3B844BC9E7595F51E3E"
console.log(Address.isValidChecksum(qrCode)) // true (all uppercase)

Database addresses: Often lowercase (valid):

const db = "0x742d35cc6634c0532925a3b844bc9e7595f51e3e"
console.log(Address.isValidChecksum(db)) // true (all lowercase)

User input: May have incorrect checksum (invalid):

const userInput = "0x742d35cc6634c0532925a3b844bc9e7595f51e3E" // Wrong!
console.log(Address.isValidChecksum(userInput)) // false (mixed case wrong)

Error Detection

Checksums help detect typos:

import { Address } from 'tevm'

// Original (correct)
const correct = "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"

// Typo: changed 'a' to 'b' at position 3
const typo = "0x5bAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"

console.log(Address.isValidChecksum(correct)) // true
console.log(Address.isValidChecksum(typo))    // false (checksum mismatch)

Detection rate: EIP-55 checksums can detect:

• ~99.986% of single character errors
• Most multi-character errors

Not detected:

• All lowercase → all lowercase (no checksum)
• All uppercase → all uppercase (no checksum)

Performance

Cryptographic operation: Uses keccak256 hash internally.

Bundle size impact: With the factory pattern, keccak256 is only bundled if you explicitly import it. Crypto dependencies are now explicit and tree-shakeable.

Alternative: Use isValid() if checksum verification not required.

Integration with Parsing

Validate before parsing:

import { Address } from 'tevm'

if (!Address.isValid(input)) {
  throw new Error('Invalid format')
}

if (!Address.isValidChecksum(input)) {
  console.warn('Invalid checksum')
}

const addr = Address(input)

Parse then validate:

import { Address } from 'tevm'

const addr = Address(input)

// Check if input had valid checksum
if (!Address.isValidChecksum(input)) {
  console.warn('Input had invalid checksum')
}

// Always return checksummed
return addr.toChecksummed()

See Also

• toChecksummed - Generate checksummed address
• isValid - Validate address format
• fromHex - Parse address from hex
• EIP-55: Mixed-case checksum
• Keccak256 - Keccak256 hash function