Hoe Werkt CREATE2?

Normaal gesproken wordt het adres van een smart contract bepaald door:

new_address = hash(sender, nonce)

Maar bij CREATE2 wordt het contractadres op voorhand berekend met deze formule:

new_address = keccak256(0xFF, sender, salt, bytecode)

Waarbij:

• 0xFF → Een vaste byte om botsingen te voorkomen.
• deployer → Het adres van de factory die het contract maakt.
• salt → Een willekeurig getal gekozen door de deployer (zorgt ervoor dat verschillende contracten met dezelfde code toch unieke adressen kunnen krijgen).
• keccak256(bytecode) → De hash van de contractcode zelf.

Voordelen van CREATE2:

• Je kunt het adres van tevoren berekenen, voordat je iets op de blockchain zet.
• Je kunt contracten "uitstellen" en pas deployen als dat nodig is.
• Je kunt contracten herstructureren of migreren, zoals in Layer 2-oplossingen.

Maar… dit opent ook de deur voor oplichters!

Rug Pull via Verborgen Code

Werkwijze:

1. De oplichter creëert een Factory Contract die tokens kan deployen met CREATE2.
2. Ze deployen een eerste, veilige token zonder rugpull-mechanismen.
3. Beleggers investeren en bouwen liquiditeit op.
4. De oplichter deployt een nieuwe versie van het contract via CREATE2 met een verborgen backdoor, zoals een 100% verkoopbelasting of een eigenaar die alle tokens kan confisqueren.
5. De community ziet hetzelfde contractadres, maar het werkt ineens anders!

Codevoorbeeld van een Factory Contract die dit mogelijk maakt:

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

contract Factory {
    function deployChild(uint256 _salt) public returns (address) {
        bytes memory bytecode = type(Child).creationCode;
        address childAddress;
        assembly {
            childAddress := create2(0, add(bytecode, 32), mload(bytecode), _salt)
        }
        require(childAddress != address(0), "Failed to deploy");
        return childAddress;
    }

    function computeChildAddress(uint256 _salt) public view returns (address) {
        bytes memory bytecode = type(Child).creationCode;
        bytes32 hash = keccak256(
            abi.encodePacked(bytes1(0xff), address(this), _salt, keccak256(bytecode))
        );
        return address(uint160(uint256(hash)));
    }
}

Waarom werkt dit?

• Gebruikers vertrouwen het contractadres, maar CREATE2 kan op een later moment nieuwe code deployen op datzelfde adres!
• Mensen controleren de code vóór de deploy, maar niet erna.

Adres-Phishing & Impersonatie

Werkwijze:

1. De oplichter berekent het adres van een toekomstig contract met CREATE2.
2. Ze gebruiken een salt zodat het adres lijkt op dat van een bekend project (bijv. Uniswap of een bekende token).
3. Zodra mensen geld naar dat adres sturen, deployt de oplichter een scam-contract nadat het geld al is overgemaakt.
4. De scam-smart contract rooft de funds zodra het live gaat.

Waarom werkt dit?

• Sommige wallets en explorers laten alleen het adres zien en niet of er code op staat!
• Mensen denken dat het een officieel contract is, maar in werkelijkheid is het een net nieuwe deploy.

Infinite Approval Exploit

** Werkwijze:**

1. De oplichter berekent een contractadres en deelt het in een Telegram-groep of Twitter als een nieuwe token die net is gelanceerd.
2. Investeerders geven goedkeuring (approve) aan dit adres om hun tokens te laten traden.
3. De oplichter deployt later een kwaadaardig contract op datzelfde adres met een transferFrom() exploit.
4. Zodra de scam-contract live gaat, steelt het alle tokens waarvoor investeerders een goedkeuring hadden gegeven.

Codevoorbeeld van een scam-token die goedgekeurde funds rooft:

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

contract EvilToken {
    function stealFunds(IERC20 token, address victim) public {
        uint256 amount = token.allowance(victim, address(this));
        token.transferFrom(victim, msg.sender, amount);
    }
}

Waarom werkt dit?

• Mensen geven approve op een adres, maar de code op dat adres kan later malafide zijn!
• Wallets tonen alleen goedkeuringen per adres, niet de actuele contractcode.
• De scam-contract gebruikt transferFrom() om alles te stelen zodra het live gaat.

Hoe Bescherm Je Jezelf?

Check of een contract via CREATE2 is gemaakt.

• Gebruik Etherscan's Bytecode History om te zien wanneer en hoe het contract is gemaakt.

Gebruik "revocable approvals".

• Gebruik tools zoals revoke.cash om goedkeuringen regelmatig te verwijderen.

Vertrouw nooit een contract dat alleen een adres deelt.

• Als iemand zegt "gebruik dit adres", maar je kunt geen contract-code zien, interactie vermijden.

Check of het contract net is gedeployed voordat je ermee interactie hebt.

• Nieuwe contracten die meteen interactie vereisen zijn verdacht.

CREATE2 is een krachtig hulpmiddel voor innovatieve use-cases zoals wallet-upgrades en Layer 2-scaling. Maar omdat het contractadressen vooraf voorspelbaar maakt, kunnen oplichters dit dus gebruiken om:

1. Een "veilig" adres te maken waar nog niks op staat, maar later via CREATE2 een scam-versie te deployen.
2. Goedkeuringen te stelen door pas later een kwaadwillig contract te deployen.
3. Door middel van CREATE2 een contract te deployen die later een selfdestruct bevat. Dit is wel deprecated, maar nog wel een mogelijkheid.

Door bewust te zijn van deze methodes en altijd de volledige contract te checken, kun je voorkomen dat je slachtoffer wordt van een CREATE2 scam.