Address.fromNumber

Create address from number or bigint

Try it Live

Run Address examples in the interactive playground

This page is a placeholder. All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.

View the complete executable example at playground/src/examples/primitives/address/from-number.ts.

Bit Masking

Takes lower 160 bits (20 bytes) of input value. Higher bits are discarded.

Formula: address = value & ((1 << 160) - 1)

Examples:

import { Address } from '@tevm/voltaire'

// Value fits in 160 bits - no truncation
const fits = 0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n
const addr1 = Address(fits)
console.log(addr1.toHex())
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3"

// Value larger than 160 bits - truncates
const large = 0x1234567890abcdef742d35Cc6634C0532925a3b844Bc9e7595f251e3n
const addr2 = Address(large)
console.log(addr2.toHex())
// "0x742d35cc6634c0532925a3b844bc9e7595f251e3" (same as addr1)

Use Cases

Sequential Addresses

Generate sequential addresses for testing:

import { Address } from '@tevm/voltaire'

const testAddresses = Array({ length: 10 }, (_, i) =>
  Address(i + 1)
)

testAddresses.forEach((addr, i) => {
  console.log(`Address ${i + 1}: ${addr.toHex()}`)
})

Address Arithmetic

Perform arithmetic on addresses:

import { Address } from '@tevm/voltaire'

function nextAddress(addr: Address): Address {
  const n = addr.toU256()
  return Address(n + 1n)
}

const addr = Address(100n)
const next = nextAddress(addr)
console.log(addr.toHex())  // "0x...0064"
console.log(next.toHex())  // "0x...0065"

Numeric Conversions

Convert between numeric and address representations:

import { Address } from '@tevm/voltaire'

// Numeric to address
const num = 0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n
const addr = Address(num)

// Address to numeric
const backToNum = addr.toU256()
console.log(num === backToNum) // true

Test Fixtures

Create predictable test addresses:

import { Address } from '@tevm/voltaire'

const TEST_ADDRESSES = {
  ZERO: Address(0n),
  ONE: Address(1n),
  MAX: Address((1n << 160n) - 1n),
  ALICE: Address(100n),
  BOB: Address(200n),
  CHARLIE: Address(300n),
}

Number vs Bigint

Number (JavaScript): Safe for values up to 2^53 - 1:

Address(69)              // ✓ Safe
Address(Number.MAX_SAFE_INTEGER) // ✓ Safe (2^53 - 1)
Address(Number.MAX_VALUE)         // ⚠ May lose precision

Bigint: Required for larger values:

Address(0x742d35Cc6634C0532925a3b844Bc9e7595f251e3n) // ✓ Safe

Recommendation: Use bigint for address-sized values (160 bits).

Error Handling

import { Address } from '@tevm/voltaire'

// Valid values
console.log(Address(0n))    // ✓ Zero address
console.log(Address(69n))   // ✓ Small value
console.log(Address((1n << 160n) - 1n)) // ✓ Max address

// Invalid: negative
try {
  Address(-1n)
} catch (e) {
  console.error(e) // InvalidValueError: Address value cannot be negative
}

try {
  Address(-69)
} catch (e) {
  console.error(e) // InvalidValueError: Address value cannot be negative
}

Overflow Behavior

Values larger than 160 bits are truncated (not an error):

import { Address } from '@tevm/voltaire'

// 256-bit value (Hash-sized)
const hash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefn

// Takes lower 160 bits
const addr = Address(hash)

// Higher bits discarded
console.log(addr.toHex())
// "0x1234567890abcdef1234567890abcdef12345678"
//   ^                                     ^ (last 40 hex chars)

Comparison with Other Constructors

import { Address } from '@tevm/voltaire'

const value = 69n

// All produce same address
const addr1 = Address(value)
const addr2 = Address(value)
const addr3 = Address("0x0000000000000000000000000000000000000045")
const addr4 = Address(new Uint8Array([0, 0, ..., 0x45]))

console.log(addr1.equals(addr2)) // true
console.log(addr1.equals(addr3)) // true
console.log(addr1.equals(addr4)) // true

When to use fromNumber():

• Have numeric value
• Performing address arithmetic
• Generating test addresses
• Converting from U256

When to use other constructors:

• fromHex() - Have hex string
• fromBytes() - Have byte array
• from() - Type unknown or mixed inputs

See Also

• from - Universal constructor
• fromHex - Parse from hex string
• fromBytes - Create from bytes
• toU256 - Convert to numeric