address Array in Solidity: Beginner Guide With Code

The keyword address is Solidity's built in type for a 20 byte Ethereum identifier. It can refer to a user wallet or to another contract. Wrapping the type in square brackets, address[], turns it into a list of those identifiers.

The mental model carries over from the earlier posts in this series. A row of boxes, each holding one value of the same type, numbered from zero. The new rule for beginners is that the empty default is address(0), the zero address. It shows up whenever you read a slot that has not been set yet.

The contract needs three operations. Add a wallet to the list. Read a wallet at any position. Know how many wallets are on the list. An address array does all three with a tiny amount of code.

Other places this same shape shows up: a voter roll for a DAO, a contestant roster in a raffle contract, an early holder snapshot before an airdrop, or a participant list for a paid event. Any time you need an ordered set of wallets, an address array is the natural structure.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Whitelist {
    // 1. Track who deployed the contract.
    address public immutable owner;

    // 2. The storage array of approved wallets.
    address[] public allowed;

    constructor() {
        owner = msg.sender;
    }

    // 3. Add a wallet to the whitelist. Owner only.
    function addAddress(address user) external {
        require(msg.sender == owner, "not owner");
        require(user != address(0), "zero address");
        allowed.push(user);
    }

    // 4. Read a wallet at a specific index.
    function getAddress(uint256 i) external view returns (address) {
        require(i < allowed.length, "index out of range");
        return allowed[i];
    }

    // 5. Return how many wallets are on the list.
    function totalAddresses() external view returns (uint256) {
        return allowed.length;
    }
}

Open Remix at remix.ethereum.org, create a new file, paste the contract, compile with the 0.8.20 compiler, and deploy to the JavaScript VM. The deploy panel shows the connected wallet, which is also the owner. Use the second account in the dropdown to confirm the access guard rejects unauthorised callers.

address public immutable owner;
address[] public allowed;

constructor() {
    owner = msg.sender;
}

The variable owner holds the deployer's wallet. The keyword immutable says the value is set once at deploy time and never changes. The constructor reads msg.sender, which is the address that submitted the deployment transaction, and saves it.

function addAddress(address user) external {
    require(msg.sender == owner, "not owner");
    require(user != address(0), "zero address");
    allowed.push(user);
}

Two require guards run before the push. The first checks that the caller is the owner so random wallets cannot pollute the list. The second blocks the zero address, which is almost always a sign of a mistake. After both pass, allowed.push(user) appends the wallet to the array and grows the length by one.

function getAddress(uint256 i) external view returns (address) {
    require(i < allowed.length, "index out of range");
    return allowed[i];
}

The return type is address, a value type that fits in one storage slot. Unlike strings, addresses do not need a memory or storage label because they are passed by value, just like a uint or an int.

function totalAddresses() external view returns (uint256) {
    return allowed.length;
}

The length is reported as a plain unsigned integer regardless of the array element type. This pattern is the same across all four types in this series.

Adding data uses allowed.push(msg.sender) when the caller is adding themselves, or allowed.push(user) when the owner is adding a specific wallet. Either way the new entry lands at the end of the list.

Reading data uses bracket lookup. The first wallet is allowed[0], the most recent is allowed[allowed.length - 1] when the list is non empty. Indexes are unsigned, so a bounds check is the standard guard.

Counting items uses allowed.length. The result is a uint256 you can compare in a require, use as an index bound for the methods in Section 06, or return for off chain code to read.

Start with the Whitelist contract you already have. Each function below goes right after the existing ones inside the contract body. None of them needs a for loop, and each one teaches a distinct rule of Solidity address storage.

Function 1. Remove the last wallet with pop

function dropLast() external {
    require(msg.sender == owner, "not owner");
    require(allowed.length > 0, "empty");
    allowed.pop();
}

allowed.pop() drops the last wallet and shrinks the length by one. The owner guard keeps the function locked down. The length guard is critical: calling pop on a zero length array triggers a panic and the transaction reverts. Add the length guard whenever the array can be empty at call time.

Function 2. Reset one slot with delete by index

function clearAt(uint256 i) external {
    require(msg.sender == owner, "not owner");
    require(i < allowed.length, "out of range");
    delete allowed[i];
}

delete allowed[i] writes the type default into the targeted slot. For an address the default is address(0), the zero address. Because most contracts treat the zero address as a special no one is set value, leaving zero address entries inside a live whitelist is rarely what you want. Compact the array with swap and pop in the next section instead.

Function 3. Wipe the entire array with delete on the variable

function clearAll() external {
    require(msg.sender == owner, "not owner");
    delete allowed;
}

delete allowed on the whole array resets every slot to address(0) and sets the length back to zero in one line. After the call, every indexed read goes out of range, and the next push starts a fresh whitelist from index zero.

Function 4. Replace a wallet with direct assignment

function replaceAt(uint256 i, address user) external {
    require(msg.sender == owner, "not owner");
    require(i < allowed.length, "out of range");
    require(user != address(0), "zero address");
    allowed[i] = user;
}

Bracket assignment writes a new address into the slot at the given index. The bounds check stops the call early when the index is past the end, and the zero address guard rejects an uninitialised input. The length does not change because the slot already existed.

After adding the four functions, your Whitelist contract now covers all five basic array operations: push, pop, delete by index, delete on the variable, and bracket assignment. Compile in Remix, redeploy, and try each new function from the deploy panel using two accounts to verify the owner guard.

Move the last wallet into the slot you want to drop, then call pop. The targeted entry disappears, the last entry takes its place, and the length shrinks by one. The trade off is that the enrolment order changes.

function removeAt(uint256 i) external {
    require(msg.sender == owner, "not owner");

    uint256 last = allowed.length - 1;
    require(i <= last, "out of range");

    if (i != last) {
        allowed[i] = allowed[last];
    }
    allowed.pop();
}

The if (i != last) guard skips a tiny self assignment when the caller asks for the last slot. After the function returns, the array length is one less than before and the previous last wallet sits at the position that was removed. The cost is constant regardless of how many wallets are on the list.

Function 6. Return the whole array as one value

Returning the whole array works when the list is small. The return type uses the memory location keyword because the caller receives a fresh copy of the wallets, not a pointer into storage. Add this function next to the rest in Whitelist.

function allAllowed() external view returns (address[] memory) {
    return allowed;
}

Pattern 1. Build a temporary memory array

Memory arrays let you build a temporary wallet list inside a function without touching storage. The size is fixed at the moment you create them with new, so you cannot push or pop on a memory array. Set the entries by index after creation. This pattern lives on its own; it does not extend Whitelist because the function is pure.

function buildBatch(address a, address b) external pure
    returns (address[] memory)
{
    address[] memory batch = new address[](2);
    batch[0] = a;
    batch[1] = b;
    return batch;
}

Pattern 2. Declare a fixed length storage array

Fixed length storage address arrays declare the slot count inside the brackets. You cannot push or pop because the size never changes. Every slot starts at address(0) and you write into the slots by index. This is a separate state variable on its own contract, not an extension of the dynamic Whitelist array.

// Three slot signer array baked into storage.
address[3] public signers;

function setSigner(uint256 i, address user) external {
    require(i < 3, "out of range");
    require(user != address(0), "zero address");
    signers[i] = user;
}

The contract below is the full version. The owner is captured once in the constructor and every function that mutates the list checks against it. The first three functions are the originals: push wrapped as addAddress, indexed read wrapped as getAddress, and the length read wrapped as totalAddresses. The remaining six are the additions you walked through in Sections 06 to 08.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Whitelist {
    address public immutable owner;
    address[] public allowed;

    constructor() {
        owner = msg.sender;
    }

    // Add a wallet to the whitelist. Owner only.
    function addAddress(address user) external {
        require(msg.sender == owner, "not owner");
        require(user != address(0), "zero address");
        allowed.push(user);
    }

    // Read a wallet at a specific index.
    function getAddress(uint256 i) external view returns (address) {
        require(i < allowed.length, "out of range");
        return allowed[i];
    }

    // Return how many wallets are on the list.
    function totalAddresses() external view returns (uint256) {
        return allowed.length;
    }

    // Function 1. Remove the most recent wallet with pop.
    function dropLast() external {
        require(msg.sender == owner, "not owner");
        require(allowed.length > 0, "empty");
        allowed.pop();
    }

    // Function 2. Reset one slot to address(0) with delete by index.
    function clearAt(uint256 i) external {
        require(msg.sender == owner, "not owner");
        require(i < allowed.length, "out of range");
        delete allowed[i];
    }

    // Function 3. Wipe the whole whitelist with delete on the variable.
    function clearAll() external {
        require(msg.sender == owner, "not owner");
        delete allowed;
    }

    // Function 4. Replace an existing wallet with direct assignment.
    function replaceAt(uint256 i, address user) external {
        require(msg.sender == owner, "not owner");
        require(i < allowed.length, "out of range");
        require(user != address(0), "zero address");
        allowed[i] = user;
    }

    // Function 5. Remove any wallet with swap and pop.
    function removeAt(uint256 i) external {
        require(msg.sender == owner, "not owner");
        uint256 last = allowed.length - 1;
        require(i <= last, "out of range");
        if (i != last) {
            allowed[i] = allowed[last];
        }
        allowed.pop();
    }

    // Function 6. Return the whole array as memory.
    function allAllowed() external view returns (address[] memory) {
        return allowed;
    }
}

Open Remix, paste the contract, compile with the 0.8.20 compiler, and redeploy to the JavaScript VM. The deploy panel now lists nine callable buttons. Use the first account in the dropdown to add three wallets, switch to a second account and confirm the owner guard rejects you on every mutator, then switch back and run removeAt(1) to watch the list compact with swap and pop. Every method you have learnt in this post lives in this single file.

Deploy the contract in Remix, switch between three accounts in the deploy panel, and call enter() from each. Confirm the length is three. Call withdrawEntry from one account and confirm the length drops to two. Then call drawWinner() a few times across different blocks and notice the index moves around with the block data.

You have now seen the four most common Solidity array element types in this beginner series. The hub guide on arrays in Solidity covers the broader rules: fixed versus dynamic shapes, storage versus memory versus calldata, the swap and pop removal pattern, and gas safe iteration. After that, the natural follow ups are mappings and structs. If you missed any earlier post in the series, start with the uint array and walk forward.