Address.is

#include "primitives.h"

// Validate before use
void processAddress(const PrimitivesAddress* addr) {
    if (!primitives_address_is_valid(addr)) {
        // Handle null pointer
        return;
    }

    // Safe to use addr
    char hex[43]; // 0x + 40 chars + null
    primitives_address_to_hex(addr, hex);
}

// Size enforced by struct (always 20 bytes)
PrimitivesAddress addr;
// sizeof(addr) == 20 guaranteed

import * as Address from '@tevm/voltaire/Address'

// Type predicate signature
function is(value: unknown): value is AddressType {
  return value instanceof Uint8Array && value.length === 20
}

// Before type guard
function example1(value: unknown) {
  const hex = value.toHex() // Type error: unknown not assignable
}

// After type guard
function example2(value: unknown) {
  if (Address.is(value)) {
    // Type narrowed to AddressType
    const hex = value.toHex() // OK
    const checksummed = value.toChecksummed() // OK
  }
}

import * as Address from '@tevm/voltaire/Address'

function handleUnknown(value: unknown) {
  if (Address.is(value)) {
    // Type: AddressType
    console.log(value.length) // 20
    const hex = value.toHex()
  } else {
    // Type: unknown
    console.log("Not an address")
  }
}

import * as Address from '@tevm/voltaire/Address'
import * as Hash from '@tevm/voltaire/Hash'

type AddressOrHash = AddressType | Hash

function process(value: AddressOrHash) {
  if (Address.is(value)) {
    // Narrowed to AddressType
    console.log("Address:", value.toHex())
  } else {
    // Narrowed to Hash
    console.log("Hash:", value.toHex())
  }
}

import * as Address from '@tevm/voltaire/Address'

const mixed: unknown[] = [
  Address(69n),
  "not an address",
  Address.zero(),
  42,
  Address("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")
]

// Filter to only addresses
const addresses = mixed.filter(Address.is)
// Type: AddressType[]

addresses.forEach(addr => {
  console.log(addr.toHex()) // Type-safe
})

import * as Address from '@tevm/voltaire/Address'

function transferTokens(to: unknown, amount: bigint) {
  if (!Address.is(to)) {
    throw new Error("Invalid recipient address")
  }

  // Type-safe operations
  if (to.equals(Address.zero())) {
    throw new Error("Cannot transfer to zero address")
  }

  // Process transfer...
}

import * as Address from '@tevm/voltaire/Address'

function parseUserInput(input: string): AddressType {
  try {
    const addr = Address(input)

    if (!Address.is(addr)) {
      throw new Error("Invalid address format")
    }

    return addr
  } catch (e) {
    throw new Error(`Failed to parse address: ${e.message}`)
  }
}

import * as Address from '@tevm/voltaire/Address'

interface Transaction {
  from: unknown
  to: unknown
  value: bigint
}

function validateTransaction(tx: Transaction): boolean {
  // Validate both addresses
  if (!Address.is(tx.from) || !Address.is(tx.to)) {
    return false
  }

  // Validate not zero addresses
  if (tx.from.equals(Address.zero())) {
    return false
  }

  return true
}

export function is(value) {
  return value instanceof Uint8Array && value.length === 20
}

Address.is(new Uint8Array(20))           // true
Address.is(Address(69n))            // true
Address.is(Address.zero())               // true

Address.is(new Uint8Array(19))           // false (wrong length)
Address.is(Bytes32())           // false (wrong length)
Address.is("0x742d35...")               // false (string)
Address.is(42n)                          // false (bigint)
Address.is(null)                         // false (null)
Address.is(undefined)                    // false (undefined)
Address.is({})                           // false (object)
Address.is(new Array(20).fill(0))       // false (Array not Uint8Array)

import * as Address from '@tevm/voltaire/Address'

function normalize(value: unknown): AddressType {
  if (Address.is(value)) {
    // Already valid address
    return value
  }

  if (typeof value === 'string') {
    return Address(value)
  }

  if (typeof value === 'bigint' || typeof value === 'number') {
    return Address(value)
  }

  throw new Error("Cannot convert to address")
}

import * as Address from '@tevm/voltaire/Address'

interface SerializedTransaction {
  from: Uint8Array
  to: Uint8Array
  value: string
}

function deserialize(data: unknown): Transaction | null {
  if (!isSerializedTransaction(data)) {
    return null
  }

  // Validate addresses
  if (!Address.is(data.from) || !Address.is(data.to)) {
    return null
  }

  return {
    from: data.from,
    to: data.to,
    value: BigInt(data.value)
  }
}

import * as Address from '@tevm/voltaire/Address'

function validateWhitelist(addresses: unknown[]): AddressType[] {
  const valid: AddressType[] = []

  for (const addr of addresses) {
    if (Address.is(addr)) {
      valid.push(addr)
    } else {
      console.warn("Skipping invalid address:", addr)
    }
  }

  return valid
}

Address.isValid("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3") // true
Address.is("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")      // false (string)

const addr = Address("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")
Address.is(addr)      // true (AddressType)
Address.isValid(addr) // false (not string)

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

const lower = Address("0x742d35cc6634c0532925a3b844bc9e7595f51e3e")
const checksum = Address("0x742d35Cc6634C0532925a3b844Bc9e7595f251e3")
Address.is(lower)    // true (valid AddressType)
Address.is(checksum) // true (valid AddressType)