ERC721 / ERC1155 / ERC4626 标准详解

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

interface IERC721 {
    // Events
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    // Balance & Ownership
    function balanceOf(address owner) external view returns (uint256 balance);
    function ownerOf(uint256 tokenId) external view returns (address owner);

    // Transfer
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
    function transferFrom(address from, address to, uint256 tokenId) external;

    // Approval
    function approve(address to, uint256 tokenId) external;
    function getApproved(uint256 tokenId) external view returns (address operator);
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// Token ownership mapping
mapping(uint256 => address) private _owners;

// Balance tracking
mapping(address => uint256) private _balances;

// Token approvals (single token)
mapping(uint256 => address) private _tokenApprovals;

// Operator approvals (all tokens)
mapping(address => mapping(address => bool)) private _operatorApprovals;

// Metadata
string private _name;
string private _symbol;
mapping(uint256 => string) private _tokenURIs;

function mint(address to, uint256 tokenId) public {
    require(to != address(0), "mint to zero address");
    require(_owners[tokenId] == address(0), "token already minted");

    _balances[to] += 1;
    _owners[tokenId] = to;

    emit Transfer(address(0), to, tokenId);
}

function transferFrom(address from, address to, uint256 tokenId) public {
    require(_isApprovedOrOwner(msg.sender, tokenId), "not owner nor approved");
    require(ownerOf(tokenId) == from, "from is not owner");
    require(to != address(0), "transfer to zero address");

    // Clear approvals
    delete _tokenApprovals[tokenId];

    // Update balances
    _balances[from] -= 1;
    _balances[to] += 1;

    // Update ownership
    _owners[tokenId] = to;

    emit Transfer(from, to, tokenId);
}

function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public {
    transferFrom(from, to, tokenId);
    require(_checkOnERC721Received(from, to, tokenId, data), "transfer to non ERC721Receiver");
}

function _checkOnERC721Received(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
) private returns (bool) {
    if (to.code.length > 0) {
        try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, data) returns (bytes4 retval) {
            return retval == IERC721Receiver.onERC721Received.selector;
        } catch {
            return false;
        }
    }
    return true;
}

interface IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// Example implementation
contract NFTHolder is IERC721Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

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

interface IERC1155 {
    // Events
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
    event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);
    event URI(string value, uint256 indexed id);

    // Balance
    function balanceOf(address account, uint256 id) external view returns (uint256);
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

    // Transfer
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;

    // Approval
    function setApprovalForAll(address operator, bool approved) external;
    function isApprovedForAll(address account, address operator) external view returns (bool);
}

// Double mapping: address => (tokenId => balance)
mapping(address => mapping(uint256 => uint256)) private _balances;

// Operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;

// Token URIs
mapping(uint256 => string) private _uris;
string private _baseURI;

function mint(address to, uint256 id, uint256 amount, bytes memory data) public {
    require(to != address(0), "mint to zero address");

    _balances[to][id] += amount;

    emit TransferSingle(msg.sender, address(0), to, id, amount);

    _doSafeTransferAcceptanceCheck(msg.sender, address(0), to, id, amount, data);
}

function mintBatch(
    address to,
    uint256[] memory ids,
    uint256[] memory amounts,
    bytes memory data
) public {
    require(to != address(0), "mint to zero address");
    require(ids.length == amounts.length, "ids and amounts length mismatch");

    for (uint256 i = 0; i < ids.length; i++) {
        _balances[to][ids[i]] += amounts[i];
    }

    emit TransferBatch(msg.sender, address(0), to, ids, amounts);

    _doSafeBatchTransferAcceptanceCheck(msg.sender, address(0), to, ids, amounts, data);
}

function safeTransferFrom(
    address from,
    address to,
    uint256 id,
    uint256 amount,
    bytes memory data
) public {
    require(to != address(0), "transfer to zero address");
    require(
        from == msg.sender || isApprovedForAll(from, msg.sender),
        "caller is not owner nor approved"
    );

    uint256 fromBalance = _balances[from][id];
    require(fromBalance >= amount, "insufficient balance");

    unchecked {
        _balances[from][id] = fromBalance - amount;
    }
    _balances[to][id] += amount;

    emit TransferSingle(msg.sender, from, to, id, amount);

    _doSafeTransferAcceptanceCheck(msg.sender, from, to, id, amount, data);
}

function safeBatchTransferFrom(
    address from,
    address to,
    uint256[] memory ids,
    uint256[] memory amounts,
    bytes memory data
) public {
    require(to != address(0), "transfer to zero address");
    require(
        from == msg.sender || isApprovedForAll(from, msg.sender),
        "caller is not owner nor approved"
    );
    require(ids.length == amounts.length, "ids and amounts length mismatch");

    for (uint256 i = 0; i < ids.length; i++) {
        uint256 id = ids[i];
        uint256 amount = amounts[i];

        uint256 fromBalance = _balances[from][id];
        require(fromBalance >= amount, "insufficient balance");

        unchecked {
            _balances[from][id] = fromBalance - amount;
        }
        _balances[to][id] += amount;
    }

    emit TransferBatch(msg.sender, from, to, ids, amounts);

    _doSafeBatchTransferAcceptanceCheck(msg.sender, from, to, ids, amounts, data);
}

interface IERC1155Receiver {
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IERC4626 is IERC20 {
    // Events
    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
    event Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares);

    // Asset Info
    function asset() external view returns (address assetTokenAddress);
    function totalAssets() external view returns (uint256 totalManagedAssets);

    // Conversion
    function convertToShares(uint256 assets) external view returns (uint256 shares);
    function convertToAssets(uint256 shares) external view returns (uint256 assets);

    // Preview
    function previewDeposit(uint256 assets) external view returns (uint256 shares);
    function previewMint(uint256 shares) external view returns (uint256 assets);
    function previewWithdraw(uint256 assets) external view returns (uint256 shares);
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    // Limits
    function maxDeposit(address receiver) external view returns (uint256 maxAssets);
    function maxMint(address receiver) external view returns (uint256 maxShares);
    function maxWithdraw(address owner) external view returns (uint256 maxAssets);
    function maxRedeem(address owner) external view returns (uint256 maxShares);

    // Actions
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);
    function mint(uint256 shares, address receiver) external returns (uint256 assets);
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract MyVault is ERC20, IERC4626 {
    IERC20 private immutable _asset;

    constructor(IERC20 asset_, string memory name_, string memory symbol_)
        ERC20(name_, symbol_)
    {
        _asset = asset_;
    }

    function asset() public view returns (address) {
        return address(_asset);
    }

    function totalAssets() public view returns (uint256) {
        return _asset.balanceOf(address(this));
    }
}

function convertToShares(uint256 assets) public view returns (uint256) {
    uint256 supply = totalSupply();
    return (supply == 0) ? assets : assets * supply / totalAssets();
}

function convertToAssets(uint256 shares) public view returns (uint256) {
    uint256 supply = totalSupply();
    return (supply == 0) ? shares : shares * totalAssets() / supply;
}

function deposit(uint256 assets, address receiver) public returns (uint256 shares) {
    require(assets <= maxDeposit(receiver), "deposit more than max");

    shares = previewDeposit(assets);

    // Transfer assets from sender to vault
    _asset.transferFrom(msg.sender, address(this), assets);

    // Mint shares to receiver
    _mint(receiver, shares);

    emit Deposit(msg.sender, receiver, assets, shares);
}

function previewDeposit(uint256 assets) public view returns (uint256) {
    return convertToShares(assets);
}

function mint(uint256 shares, address receiver) public returns (uint256 assets) {
    require(shares <= maxMint(receiver), "mint more than max");

    // Round up to protect vault
    assets = _convertToAssets(shares, Math.Rounding.Up);

    _asset.transferFrom(msg.sender, address(this), assets);
    _mint(receiver, shares);

    emit Deposit(msg.sender, receiver, assets, shares);
}

function withdraw(uint256 assets, address receiver, address owner) public returns (uint256 shares) {
    require(assets <= maxWithdraw(owner), "withdraw more than max");

    // Round up to protect vault
    shares = _convertToShares(assets, Math.Rounding.Up);

    // If caller is not owner, check and spend allowance
    if (msg.sender != owner) {
        _spendAllowance(owner, msg.sender, shares);
    }

    // Burn shares from owner
    _burn(owner, shares);

    // Transfer assets to receiver
    _asset.transfer(receiver, assets);

    emit Withdraw(msg.sender, receiver, owner, assets, shares);
}

function redeem(uint256 shares, address receiver, address owner) public returns (uint256 assets) {
    require(shares <= maxRedeem(owner), "redeem more than max");

    assets = previewRedeem(shares);

    if (msg.sender != owner) {
        _spendAllowance(owner, msg.sender, shares);
    }

    _burn(owner, shares);
    _asset.transfer(receiver, assets);

    emit Withdraw(msg.sender, receiver, owner, assets, shares);
}

// Vulnerable to inflation attack
constructor() {
    // Empty - First depositor can manipulate exchange rate
}

// Protection: Mint initial virtual shares
constructor() {
    _mint(address(this), 1000);  // Lock initial shares in vault
}

// Or: Use a minimum deposit requirement
function deposit(uint256 assets, address receiver) public returns (uint256 shares) {
    require(assets >= MIN_DEPOSIT, "deposit too small");
    // ...
}