Within an Ethereum transaction, the zero-account is just a special case used to indicate that a new contract is being deployed. It is literally '0x0' set to the to field in the raw transaction.

Every Ethereum transaction, whether it's a transfer between two external accounts, a request to execute contract code, or a request to deploy a new contract, are encoded in the same way. A raw transaction object will look something like this:

transaction = {
  nonce: '0x0', 
  gasLimit: '0x6acfc0', // 7000000
  gasPrice: '0x4a817c800', // 20000000000
  to: '0x0',
  value: '0x0',
  data: '0xfffff'
};

If to is set to something other than '0x0', this request will result in transferring ether to the address (if value is non-zero), and execute the function encoded in the data field. Remember, the address can either be a contract or an external account.

When the to address is the zero-address, a new contract will be created by executing the code in data (this is what is meant by "code that returns the code"). The address of the newly created contract is technically known beforehand as it's based on the address of the sender and it's current nonce. That address becomes the official address of the contract after mining.

For a pretty good read on Ethereum transactions, check out this blog post.

Note: There is also the actual Solidity code statement address(0) which is the initial value of a variable of type address. The documentation you posted, however, is referring to specifically when the to account address in a transaction is set to '0x0'.

You can simply use 0, or 0x0000000000000000000000000000000000000000.

address(0) in Solidity is equivalent to 0x0000000000000000000000000000000000000000.

So, for now, transferring to what we call a long-zero address (an address obtained by converting an accountId to its solidity expression 0.0.536603 -> 0x0000000000000000000000000000000000536603) via a JSON-RPC transaction will fail.

However, transferring to an EVM address using a JSON-RPC transaction will work, see example below:

    console.log("Transfer to EVM address");
    let tx = {
        to: `0xb8482dc06049cdff56a6b747330f06de3cc1efc0`,
        value: ethers.parseEther('3', 'wei')
    };
    let transaction = await signer.sendTransaction(tx);

The EVM address for an account only exists if the account was first created by sending hbar or tokens to this address. An account created with the SDK will only have a long-zero EVM address.

Alternatively, you can use the SDK to transfer to any of the three address types:

    import {
        AccountId,
        Client, Hbar,
        PrivateKey, TransferTransaction
    } from "@hashgraph/sdk";
    import dotenv from "dotenv";

    dotenv.config();
    
    async function main() {

        let client = Client.forName(process.env.HEDERA_NETWORK).setOperator(
            AccountId.fromString(process.env.OPERATOR_ID),
            PrivateKey.fromString(process.env.OPERATOR_KEY)
        );
        console.log("Transfer to accountId");
        response = await new TransferTransaction()
            .addHbarTransfer(client.operatorAccountId, new Hbar(1).negated())
            .addHbarTransfer(AccountId.fromString("0.0.5465603"), new Hbar(1))
            .execute(client);
        await response.getReceipt(client);

        console.log("Transfer to solidity address");
        response = await new TransferTransaction()
            .addHbarTransfer(client.operatorAccountId, new Hbar(1).negated())
            .addHbarTransfer("0x0000000000000000000000000000000000536603", new Hbar(1))
            .execute(client);
        await response.getReceipt(client);

        console.log("Transfer to EVM address");
        let response = await new TransferTransaction()
            .addHbarTransfer(client.operatorAccountId, new Hbar(1).negated())
            .addHbarTransfer("0xb8482dc06049cdff56a6b747330f06de3cc1efc0", new Hbar(1))
            .execute(client);
        await response.getReceipt(client);
        
        client.close();
    }

    void main();

Section 4.2 : The Transaction from the Ethereum Yellow Paper (p4-5) defines the "zero-address / zero-account" as an:

RLP empty byte sequence.

So it Ethereum or Solidity, it looks like:

0x0000000000000000000000000000000000000000    // "zero-address" = 20 bytes of '00'

As described below, there is a conditional check to see if the transaction intend to transfer funds or create a new contract:

• If it's a 20-byte address hash, then it is a transfer of ethers.
• If it's an RLP empty byte sequence, then it is a contract creation.

I was wondering if it is ever possible to sign and send a transaction using the zero address.

Only if you hold the private key controlling the zero address. Which is currently probably unknown, maybe even non-existing. As you can see, there are currently no sent transactions from this address.

require(msg.sender == address(0))

This statement has about the same value as checking require(block.timestamp == 0). Which, if the EVM works correctly, will never happen.

I can't speak for the author's intentions - maybe they confused msg.sender with the fact that it's common practice to emit the Transfer() event with the first argument having the 0x0 address (usually used for minting tokens, which looks like if they were sent from the 0x0 address).

Note: Until 2017, it was possible to send a specifically signed transaction (without the correct private key) that resulted in the msg.sender having the null sender address 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF. This was fixed in the EIP-86, you can find more details in this article.

You can use ethers constants.

In hardhat tests, ethers lib are imported by default, so you don't need to add the require sentence.

Happy coding!

     it('Should not allow 0 address to be added', async () => {
        await expect(greeter.addWhitelistAddress(ethers.constants.AddressZero)).to.be.revertedWith(
          'Invalid address'
        );
      });