Address

import * as Address from 'voltaire-effect/primitives/Address'
import * as S from 'effect/Schema'

// Decode from hex string
const addr = S.decodeSync(Address.Hex)('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')

// Use pure functions directly
Address.isZero(addr)        // false
Address.isValid('0x...')    // true

const addr = S.decodeSync(Address.Hex)(
  '0x742d35Cc6634C0532925a3b844Bc9e7595f251e3'
)

// Encode back to lowercase hex
const hex = S.encodeSync(Address.Hex)(addr)
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"

const addr = S.decodeSync(Address.Bytes)(new Uint8Array(20))

import * as Effect from 'effect/Effect'
import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'

const checksummed = await Effect.runPromise(
  S.encode(Address.Checksummed)(addr).pipe(Effect.provide(KeccakLive))
)
// "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"

// From various input types
Address.from(value)           // Effect<AddressType, AddressError>
Address.fromHex(hex)          // Effect<AddressType, HexError>
Address.fromBytes(bytes)      // Effect<AddressType, LengthError>
Address.fromNumber(n)         // Effect<AddressType, ValueError>
Address.fromBase64(str)       // Effect<AddressType, LengthError>
Address.fromAbiEncoded(bytes) // Effect<AddressType, AbiError>
Address.fromPublicKey(pk)     // Effect<AddressType, ValueError>
Address.fromPrivateKey(sk)    // Effect<AddressType, ValueError>
Address.zero()                // AddressType (pure, never fails)

import * as Address from 'voltaire-effect/primitives/Address'
import * as Effect from 'effect/Effect'

const parseAddress = (input: string) =>
  Address.from(input).pipe(
    Effect.catchAll((error) =>
      Effect.fail(new Error(`Invalid address: ${error.message}`))
    )
  )

// Run the effect
const result = await Effect.runPromise(parseAddress('0x742d35cc6634c0532925a3b844bc9e7595f251e3'))

Address.equals(addr1, addr2)      // boolean
Address.compare(addr1, addr2)     // -1 | 0 | 1
Address.lessThan(addr1, addr2)    // boolean
Address.greaterThan(addr1, addr2) // boolean

Address.isValid('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')  // true
Address.isValid('0x123')  // false (wrong length)

Address.isValidChecksum('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3')  // true
Address.isValidChecksum('0x742d35cc6634c0532925a3b844bc9e7595f251e3')  // false

Address.isZero(addr)      // boolean
Address.isAddress(value)  // boolean (validates format)
Address.is(value)         // type guard

Address.clone(addr)       // AddressType (new copy)
Address.toBytes(addr)     // Uint8Array
Address.toHex(addr)       // "0x..." (lowercase)
Address.toLowercase(addr) // "0x742d35cc..."
Address.toUppercase(addr) // "0x742D35CC..."
Address.toShortHex(addr)  // "0x742d...51e3"
Address.toU256(addr)      // bigint
Address.toAbiEncoded(addr) // Uint8Array(32)

Address.sortAddresses([addr1, addr2, addr3])       // sorted array
Address.deduplicateAddresses([addr1, addr1, addr2]) // [addr1, addr2]

// Basic validation
const program = Address.assert('0x742d35cc6634c0532925a3b844bc9e7595f251e3')

// Strict checksum validation
const strictProgram = Address.assert('0x742d35Cc6634C0532925a3b844Bc9e7595f251e3', { strict: true })

// Non-strict (no checksum validation)
Address.assertBasic(value) // Effect<void, InvalidAddressError>

import { KeccakLive } from 'voltaire-effect/crypto/Keccak256'

const program = Address.toChecksummed(addr)
const checksummed = await Effect.runPromise(program.pipe(Effect.provide(KeccakLive)))
// "0x742d35Cc6634C0532925a3b844Bc9e7595f251e3"

const program = Address.calculateCreateAddress(deployerAddr, 0n)
const contractAddr = await Effect.runPromise(program)

const program = Address.calculateCreate2Address(deployerAddr, salt, initCode)
const contractAddr = await Effect.runPromise(program)

import * as Address from 'voltaire-effect/primitives/Address'
import * as S from 'effect/Schema'
import * as Effect from 'effect/Effect'

const parseAddress = (input: string) =>
  S.decode(Address.Hex)(input).pipe(
    Effect.catchTag('ParseError', () =>
      Effect.fail(new Error('Invalid Ethereum address'))
    )
  )

const addresses = [addr1, addr2, addr3]
const sorted = addresses.toSorted(Address.compare)

const transfer = (to: AddressType, amount: bigint) =>
  Effect.gen(function* () {
    if (Address.isZero(to)) {
      return yield* Effect.fail(new Error('Cannot transfer to zero address'))
    }
    // ... proceed with transfer
  })

const display = Address.toShortHex(addr)  // "0x742d...51e3"

import type { AddressType } from 'voltaire-effect/primitives/Address'

function transfer(to: AddressType, amount: bigint) {
  // Type-safe address handling
}