Smart-Contract-Entwicklung

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

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

contract DeFiProtocol is ReentrancyGuard, Ownable, Pausable {
    mapping(address => uint256) public userDeposits;
    uint256 public totalDeposits;

    // Benutzerdefinierte Fehler — gaseffizient (nur 4-Byte-Selektor)
    error InsufficientBalance();
    error InvalidAmount();
    error TransferFailed();

    event Deposit(address indexed user, uint256 amount, uint256 timestamp);
    event Withdrawal(address indexed user, uint256 amount, uint256 rewards);

    // OZ v5: the initial owner is a constructor argument
    constructor() Ownable(msg.sender) {}

    function deposit(uint256 amount) external nonReentrant whenNotPaused {
        if (amount == 0) revert InvalidAmount();
        // ... checks-effects-interactions
    }
}

// Benutzerdefinierte Fehler vs require-Strings
// Schlecht: require(amount > 0, "Amount must be greater than zero");
// Gut:     if (amount == 0) revert InvalidAmount();

// Struct-Packing — 2 Slots statt 3
struct UserInfo {
    uint128 amount;      // 16 Bytes ─┐
    uint128 rewardDebt;  // 16 Bytes ─┘ Slot 1
    bool isActive;       // 1 Byte  ──── Slot 2
}

// Unchecked-Arithmetik bei sicheren Eingaben
function calculateReward(uint256 principal, uint256 rate)
    internal pure returns (uint256)
{
    unchecked {
        return principal * rate / 10000;
    }
}

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceAwareProtocol {
    AggregatorV3Interface internal priceFeed;
    uint256 public constant STALENESS_THRESHOLD = 3600; // 1 Stunde
    uint256 public fallbackPrice;

    function getPrice() public view returns (uint256) {
        try priceFeed.latestRoundData() returns (
            uint80, int256 price, uint256, uint256 updatedAt, uint80
        ) {
            if (block.timestamp - updatedAt > STALENESS_THRESHOLD)
                return fallbackPrice;
            if (price <= 0) return fallbackPrice;
            return uint256(price);
        } catch {
            return fallbackPrice;
        }
    }
}

function swap(uint256 amountIn, bool aToB) external returns (uint256 amountOut) {
    require(amountIn > 0, "Invalid input amount");

    uint256 reserveIn  = aToB ? reserveA : reserveB;
    uint256 reserveOut = aToB ? reserveB : reserveA;

    // 0,3% Gebuehr anwenden
    uint256 amountInWithFee = amountIn * 997;
    amountOut = (amountInWithFee * reserveOut)
              / (reserveIn * 1000 + amountInWithFee);

    require(amountOut > 0, "Insufficient output amount");
    // ... Token transferieren, Reserven aktualisieren, Swap-Event emittieren
}

modifier updateReward(address account) {
    rewardPerTokenStored = rewardPerToken();
    lastUpdateTime = block.timestamp;
    if (account != address(0)) {
        rewards[account] = earned(account);
        userRewardPerTokenPaid[account] = rewardPerTokenStored;
    }
    _;
}

function earned(address account) public view returns (uint256) {
    return (balances[account] *
        (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18
        + rewards[account];
}

// lib/wagmi.ts
import { getDefaultConfig } from '@rainbow-me/rainbowkit';
import { mainnet, polygon, arbitrum, base } from 'wagmi/chains';

export const config = getDefaultConfig({
  appName: 'CryptaCore DeFi',
  projectId: 'YOUR_WALLETCONNECT_PROJECT_ID',
  chains: [mainnet, polygon, arbitrum, base],
  ssr: true,
});

TipDeployen Sie immer zuerst auf einem Testnet. Sowohl Foundrys forge script als auch Hardhats Deployment-Framework unterstuetzen Multi-Chain-Deployments mit Verifizierung. Fuehren Sie Ihre vollstaendige Testsuite gegen einen Mainnet-Fork aus, bevor Sie in Produktion gehen.