_section: Addresses @<addresses>

Explain addresses,formats and checksumming here.

Also see: [constants.AddressZero](constants)

_subsection: Address Formats  @<address-formats>


_heading: Address  @<address>

An **Address** is a [[DataHexString]] of 20 bytes (40 nibbles), with optional
mixed case.

If the case is mixed, it is a **Checksum Address**, which uses a specific pattern
of uppercase and lowercase letters within a given address to reduce the risk
of errors introduced from typing an address or cut and paste issues.

All functions that return an Address will return a Checksum Address.


_heading: ICAP Address  @<address-icap>

The **ICAP Address Format** was an early attempt to introduce a checksum
into Ethereum addresses using the popular banking industry's
[IBAN](link-wiki-iban)
format with the country code specified as **XE**.

Due to the way IBAN encodes address, only addresses that fit into 30 base-36
characters are actually compatible, so the format was adapted to support 31
base-36 characters which is large enough for a full Ethereum address, however
the preferred method was to select a private key whose address has a ``0`` as
the first byte, which allows the address to be formatted as a fully compatibly
standard IBAN address with 30 base-36 characters.

In general this format is no longer widely supported anymore, however any function that
accepts an address can receive an ICAP address, and it will be converted internally.

To convert an address into the ICAP format, see [getIcapAddress](utils-getIcapAddress).


_subsection: Converting and Verifying @<utils--address>

_property: ethers.utils.getAddress(address) => string<[[address]]>  @<utils-getAddress> @SRC<address>
Returns //address// as a Checksum Address.

If //address// is an invalid 40-nibble [[HexString]] or if it contains mixed case and
the checksum is invalid, an InvalidArgument Error is thrown.

The value of //address// may be any supported address format.

_property: ethers.utils.getIcapAddress(address) => string<[IcapAddress](address-icap)>  @<utils-getIcapAddress> @SRC<address>
Returns //address// as an [ICAP address](link-icap).
Supports the same restrictions as [utils.getAddress](utils-getAddress).

_property: ethers.utils.isAddress(address) => boolean  @<utils-isAddress> @SRC<address>
Returns true if //address// is valid (in any supported format).


_subsection: Derivation @<utils--address-derivation>

_property: ethers.utils.computeAddress(publicOrPrivateKey) => string<[[address]]>  @<utils-computeAddress> @SRC<transactions>
Returns the address for //publicOrPrivateKey//. A public key may be
compressed or uncompressed, and a private key will be converted
automatically to a public key for the derivation.

_property: ethers.utils.recoverAddress(digest, signature) => string<[[address]]>  @<utils-recoverAddress> @SRC<transactions>
Use [[link-wiki-ecrecover]] to determine the address that signed //digest// to
which generated //signature//.


_subsection: Contracts Addresses @<utils--contract-addresses>

_property: ethers.utils.getContractAddress(transaction) => string<[[address]]>  @<utils-getContractAddress> @SRC<address>
Returns the contract address that would result if //transaction// was
used to deploy a contract.

_property: ethers.utils.getCreate2Address(from, salt, initCodeHash) => string<[[address]]> @<utils-getCreate2Address> @SRC<address>
Returns the contract address that would result from the given
[CREATE2](link-eip-1014) call.