[ERC7943] 現実世界の資産を安全に扱うUniversal RWAの仕組みを理解しよう！

/// @notice Interface for ERC-20 based implementations.
interface IERC7943Fungible is IERC165 {
    /// @notice Emitted when tokens are taken from one address and transferred to another.
    /// @param from The address from which tokens were taken.
    /// @param to The address to which seized tokens were transferred.
    /// @param amount The amount seized.
    event ForcedTransfer(address indexed from, address indexed to, uint256 amount);

    /// @notice Emitted when `setFrozenTokens` is called, changing the frozen `amount` of tokens for `user`.
    /// @param user The address of the user whose tokens are being frozen.
    /// @param amount The amount of tokens frozen after the change.
    event Frozen(address indexed user, uint256 amount);

    /// @notice Error reverted when a user is not allowed to interact. 
    /// @param account The address of the user which is not allowed for interactions.
    error ERC7943NotAllowedUser(address account);

    /// @notice Error reverted when a transfer is attempted from `user` with an `amount` less or equal than its balance, but greater than its unfrozen balance.
    /// @param user The address holding the tokens.
    /// @param amount The amount being transferred.
    /// @param unfrozen The amount of tokens that are unfrozen and available to transfer.
    error ERC7943InsufficientUnfrozenBalance(address user, uint256 amount, uint256 unfrozen);

    /// @notice Takes tokens from one address and transfers them to another.
    /// @dev Requires specific authorization. Used for regulatory compliance or recovery scenarios.
    /// @param from The address from which `amount` is taken.
    /// @param to The address that receives `amount`.
    /// @param amount The amount to force transfer.
    function forcedTransfer(address from, address to, uint256 amount) external;

    /// @notice Changes the frozen status of `amount` tokens belonging to a `user`.
    /// This overwrites the current value, similar to an `approve` function.
    /// @dev Requires specific authorization. Frozen tokens cannot be transferred by the user.
    /// @param user The address of the user whose tokens are to be frozen/unfrozen.
    /// @param amount The amount of tokens to freeze/unfreeze.
    function setFrozenTokens(address user, uint256 amount) external;

    /// @notice Checks if a specific user is allowed to interact according to token rules.
    /// @dev This is often used for allowlist/KYC/KYB/AML checks.
    /// @param user The address to check.
    /// @return allowed True if the user is allowed, false otherwise.
    function isUserAllowed(address user) external view returns (bool allowed);

    /// @notice Checks the frozen status/amount.
    /// @param user The address of the user.
    /// @return amount The amount of tokens currently frozen for `user`.
    function getFrozenTokens(address user) external view returns (uint256 amount);

    /// @notice Checks if a transfer is currently possible according to token rules. It enforces validations on the frozen tokens.
    /// @dev This may involve checks like allowlists, blocklists, transfer limits and other policy-defined restrictions.
    /// @param from The address sending tokens.
    /// @param to The address receiving tokens. 
    /// @param amount The amount being transferred.
    /// @return allowed True if the transfer is allowed, false otherwise.
    function canTransfer(address from, address to, uint256 amount) external view returns (bool allowed);
}

event ForcedTransfer(address indexed from, address indexed to, uint256 amount);

event Frozen(address indexed user, uint256 amount);

error ERC7943NotAllowedUser(address account);

error ERC7943InsufficientUnfrozenBalance(address user, uint256 amount, uint256 unfrozen);

function forcedTransfer(address from, address to, uint256 amount) external;

function setFrozenTokens(address user, uint256 amount) external;

function isUserAllowed(address user) external view returns (bool allowed);

function getFrozenTokens(address user) external view returns (uint256 amount);

function canTransfer(address from, address to, uint256 amount) external view returns (bool allowed);

/// @notice Interface for ERC-721 based implementations.
interface IERC7943NonFungible is IERC165 {
    /// @notice Emitted when `tokenId` is taken from one address and transferred to another.
    /// @param from The address from which `tokenId` is taken.
    /// @param to The address to which seized `tokenId` is transferred.
    /// @param tokenId The ID of the token being transferred.
    event ForcedTransfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /// @notice Emitted when `setFrozenTokens` is called, changing the frozen status of `tokenId` for `user`.
    /// @param user The address of the user whose `tokenId` is subjected to freeze/unfreeze.
    /// @param tokenId The ID of the token subjected to freeze/unfreeze.
    /// @param frozenStatus Whether `tokenId` has been frozen or unfrozen.
    event Frozen(address indexed user, uint256 indexed tokenId, bool indexed frozenStatus);

    /// @notice Error reverted when a user is not allowed to interact. 
    /// @param account The address of the user which is not allowed for interactions.
    error ERC7943NotAllowedUser(address account);

    /// @notice Error reverted when a transfer is attempted from `user` with a `tokenId` which has been previously frozen.
    /// @param user The address holding the tokens.
    /// @param tokenId The ID of the token being frozen. 
    error ERC7943FrozenTokenId(address user, uint256 tokenId);

    /// @notice Takes `tokenId` from one address and transfers it to another.
    /// @dev Requires specific authorization. Used for regulatory compliance or recovery scenarios.
    /// @param from The address from which `tokenId` is taken.
    /// @param to The address that receives `tokenId`.
    /// @param tokenId The ID of the token being transferred.
    function forcedTransfer(address from, address to, uint256 tokenId) external;

    /// @notice Changes the frozen status of `tokenId` belonging to a `user`.
    /// This overwrites the current value, similar to an `approve` function.
    /// @dev Requires specific authorization. Frozen tokens cannot be transferred by the user.
    /// @param user The address of the user whose tokens are to be frozen/unfrozen.
    /// @param tokenId The ID of the token to freeze/unfreeze.
    /// @param frozenStatus whether `tokenId` is being frozen or not. 
    function setFrozenTokens(address user, uint256 tokenId, bool frozenStatus) external;

    /// @notice Checks if a specific user is allowed to interact according to token rules.
    /// @dev This is often used for allowlist/KYC/KYB/AML checks.
    /// @param user The address to check.
    /// @return allowed True if the user is allowed, false otherwise.
    function isUserAllowed(address user) external view returns (bool allowed);

    /// @notice Checks the frozen status of a specific `tokenId`.
    /// @param user The address of the user.
    /// @param tokenId The ID of the token.
    /// @return frozenStatus Whether `tokenId` is currently frozen for `user`.
    function getFrozenTokens(address user, uint256 tokenId) external view returns (bool frozenStatus);

    /// @notice Checks if a transfer is currently possible according to token rules. It enforces validations on the frozen tokens.
    /// @dev This may involve checks like allowlists, blocklists, transfer limits and other policy-defined restrictions.
    /// @param from The address sending tokens.
    /// @param to The address receiving tokens. 
    /// @param tokenId The ID of the token being transferred.
    /// @return allowed True if the transfer is allowed, false otherwise.
    function canTransfer(address from, address to, uint256 tokenId) external view returns (bool allowed);
}

/// @notice Interface for ERC-1155 based implementations.
interface IERC7943MultiToken is IERC165 {
    /// @notice Emitted when tokens are taken from one address and transferred to another.
    /// @param from The address from which tokens were taken.
    /// @param to The address to which seized tokens were transferred.
    /// @param tokenId The ID of the token being transferred.
    /// @param amount The amount seized.
    event ForcedTransfer(address indexed from, address indexed to, uint256 indexed tokenId, uint256 amount);

    /// @notice Emitted when `setFrozenTokens` is called, changing the frozen `amount` of `tokenId` tokens for `user`.
    /// @param user The address of the user whose tokens are being frozen.
    /// @param tokenId The ID of the token being frozen.
    /// @param amount The amount of tokens frozen after the change.
    event Frozen(address indexed user, uint256 indexed tokenId, uint256 amount);

    /// @notice Error reverted when a user is not allowed to interact. 
    /// @param account The address of the user which is not allowed for interactions.
    error ERC7943NotAllowedUser(address account);

    /// @notice Error reverted when a transfer is attempted from `user` with an `amount` of `tokenId` less or equal than its balance, but greater than its unfrozen balance.
    /// @param user The address holding the tokens.
    /// @param tokenId The ID of the token being transferred. 
    /// @param amount The amount being transferred.
    /// @param unfrozen The amount of tokens that are unfrozen and available to transfer.
    error ERC7943InsufficientUnfrozenBalance(address user, uint256 tokenId, uint256 amount, uint256 unfrozen);

    /// @notice Takes tokens from one address and transfers them to another.
    /// @dev Requires specific authorization. Used for regulatory compliance or recovery scenarios.
    /// @param from The address from which `amount` is taken.
    /// @param to The address that receives `amount`.
    /// @param tokenId The ID of the token being transferred.
    /// @param amount The amount to force transfer.
    function forcedTransfer(address from, address to, uint256 tokenId, uint256 amount) external;

    /// @notice Changes the frozen status of `amount` of `tokenId` tokens belonging to a `user`.
    /// This overwrites the current value, similar to an `approve` function.
    /// @dev Requires specific authorization. Frozen tokens cannot be transferred by the user.
    /// @param user The address of the user whose tokens are to be frozen/unfrozen.
    /// @param tokenId The ID of the token to freeze/unfreeze.
    /// @param amount The amount of tokens to freeze/unfreeze. 
    function setFrozenTokens(address user, uint256 tokenId, uint256 amount) external;

    /// @notice Checks if a specific user is allowed to interact according to token rules.
    /// @dev This is often used for allowlist/KYC/KYB/AML checks.
    /// @param user The address to check.
    /// @return allowed True if the user is allowed, false otherwise.
    function isUserAllowed(address user) external view returns (bool allowed);

    /// @notice Checks the frozen status/amount of a specific `tokenId`.
    /// @param user The address of the user.
    /// @param tokenId The ID of the token.
    /// @return amount The amount of `tokenId` tokens currently frozen for `user`.
    function getFrozenTokens(address user, uint256 tokenId) external view returns (uint256 amount);

    /// @notice Checks if a transfer is currently possible according to token rules. It enforces validations on the frozen tokens.
    /// @dev This may involve checks like allowlists, blocklists, transfer limits and other policy-defined restrictions.
    /// @param from The address sending tokens.
    /// @param to The address receiving tokens. 
    /// @param tokenId The ID of the token being transferred.
    /// @param amount The amount being transferred.
    /// @return allowed True if the transfer is allowed, false otherwise.
    function canTransfer(address from, address to, uint256 tokenId, uint256 amount) external view returns (bool allowed);
}

contract ComplianceOperator is IERC7943MultiToken {
    // ... 必要な状態変数やコンストラクタ、アクセス制御などを実装 ...

    function setFrozenTokensWithProof(
        address user,
        uint256 tokenId,
        uint256 amount,
        bytes calldata legalProof
    ) public {
        /// legalProof の検証・記録などをここで実施
        token.setFrozenToken(user, tokenId, amount);
    }
}

function setFrozenTokensWithProof(
    address user,
    uint256 tokenId,
    uint256 amount,
    bytes calldata legalProof
) public {
    /// do anything with `legalProof`
    token.setFrozenToken(user, tokenId, amount);
}

event Frozen(address indexed user, uint256 amount);

event ForcedTransfer(address indexed from, address indexed to, uint256 amount);

function isUserAllowed(address user) external view returns (bool allowed);

function canTransfer(address from, address to, uint256 amountOrTokenId) external view returns (bool allowed);

function getFrozenTokens(address user[, uint256 tokenId]) external view returns (uint256 amountOrStatus);

function setFrozenTokens(address user[, uint256 tokenId], uint256 amountOrStatus) external;

function forcedTransfer(address from, address to[, uint256 tokenId], uint256 amountOrOne) external;

pragma solidity ^0.8.29;

/* required imports ... */

contract uRWA20 is Context, ERC20, AccessControlEnumerable, IERC7943Fungible {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
    bytes32 public constant ENFORCER_ROLE = keccak256("ENFORCER_ROLE");
    bytes32 public constant WHITELIST_ROLE = keccak256("WHITELIST_ROLE");

    mapping(address user => bool whitelisted) public isWhitelisted;
    mapping(address user => uint256 amount) internal _frozenTokens;

    event Whitelisted(address indexed account, bool status);
    error NotZeroAddress();

    constructor(string memory name, string memory symbol, address initialAdmin) ERC20(name, symbol) {
        /* give initialAdmin necessary roles ...*/
    }

    function canTransfer(address from, address to, uint256 amount) public virtual view returns (bool allowed) {
        if (balanceOf(from) < _frozenTokens[from]) return;
        if (amount > balanceOf(from) - _frozenTokens[from]) return;
        if (!isUserAllowed(from) || !isUserAllowed(to)) return;
        allowed = true;
    }

    function isUserAllowed(address user) public virtual view returns (bool allowed) {
        if (isWhitelisted[user]) allowed = true;
    } 

    function getFrozenTokens(address user) external view returns (uint256 amount) {
        amount = _frozenTokens[user];
    }

    function changeWhitelist(address account, bool status) external onlyRole(WHITELIST_ROLE) {
        require(account != address(0), NotZeroAddress());
        isWhitelisted[account] = status;
        emit Whitelisted(account, status);
    }

    /* standard mint and burn functions with access control ...*/ 

    function setFrozenTokens(address user, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        _frozenTokens[user] = amount;
        emit Frozen(user, amount);
    }

    function forcedTransfer(address from, address to, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        _excessFrozenUpdate(from, amount);
        super._update(from, to, amount);
        emit ForcedTransfer(from, to, amount);
    }

    function _excessFrozenUpdate(address user, uint256 amount) internal {
        uint256 unfrozenBalance = _unfrozenBalance(user);
        if(amount > unfrozenBalance && amount <= balanceOf(user)) { 
            // Protect from underflow: if amount > balanceOf(user) the call will revert in super._update with insufficient balance error
            _frozenTokens[user] -= amount - unfrozenBalance; // Reduce by excess amount
            emit Frozen(user, _frozenTokens[user]);
        }
    }

    function _unfrozenBalance(address user) internal view returns(uint256 unfrozenBalance) {
        unfrozenBalance = balanceOf(user) < _frozenTokens[user] ? 0 : balanceOf(user) - _frozenTokens[user];
    }

    function _update(address from, address to, uint256 amount) internal virtual override {
        if (from != address(0) && to != address(0)) { // Transfer
            require(amount <= balanceOf(from), IERC20Errors.ERC20InsufficientBalance(from, balanceOf(from), amount));
            uint256 unfrozenBalance = _unfrozenBalance(from);
            require(amount <= unfrozenBalance, ERC7943InsufficientUnfrozenBalance(from, amount, unfrozenBalance));
            require(canTransfer(from, to, amount), "ERC7943: transfer not allowed");
        } else if (from == address(0)) { // Mint
            require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        } else { // Burn
            _excessFrozenUpdate(from, amount);
        }

        super._update(from, to, amount);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, IERC165) returns (bool) {
        return interfaceId == type(IERC7943Fungible).interfaceId ||
            interfaceId == type(IERC20).interfaceId ||
            super.supportsInterface(interfaceId);
    }
}

pragma solidity ^0.8.29;

/* required imports ... */

contract uRWA721 is Context, ERC721, AccessControlEnumerable, IERC7943NonFungible {
    /* same definitions, constructor and changeWhitelist function as before ...*/
    
    mapping(address user => mapping(uint256 tokenId => bool frozen)) internal _frozenTokens;

    function isUserAllowed(address user) public view virtual override returns (bool allowed) {
        if (isWhitelisted[user]) allowed = true;        
    }

    function canTransfer(address from, address to, uint256 tokenId) public view virtual override returns (bool allowed) {
        address owner = _ownerOf(tokenId);
        if (owner != from || owner == address(0)) return;
        if (!isUserAllowed(from) || !isUserAllowed(to)) return;
        if (_frozenTokens[from][tokenId]) return;
        allowed = true;
    }

    function getFrozenTokens(address user, uint256 tokenId) external view returns (bool frozenStatus) {
        frozenStatus = _frozenTokens[user][tokenId];
    }

    function setFrozenTokens(address user, uint256 tokenId, bool frozenStatus) public onlyRole(ENFORCER_ROLE) {
        require(user == ownerOf(tokenId), IERC721Errors.ERC721InvalidOwner(user));
        _frozenTokens[user][tokenId] = frozenStatus;
        emit Frozen(user, tokenId, frozenStatus);
    }

    function forcedTransfer(address from, address to, uint256 tokenId) public virtual override onlyRole(ENFORCER_ROLE) {
        require(to != address(0), ERC721InvalidReceiver(address(0)));
        require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        _excessFrozenUpdate(from , tokenId);
        super._update(to, tokenId, address(0)); // Skip _update override
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, "");
        emit ForcedTransfer(from, to, tokenId);
    }

    function _excessFrozenUpdate(address from, uint256 tokenId) internal {
        _validateCorrectOwner(from, tokenId);
        if(_frozenTokens[from][tokenId]) {
            _frozenTokens[from][tokenId] = false; // Unfreeze the token if it was frozen
            emit Frozen(from, tokenId, false);
        }
    }

    function _validateCorrectOwner(address claimant, uint256 tokenId) internal view {
        address currentOwner = ownerOf(tokenId);
        require(currentOwner == claimant, ERC721IncorrectOwner(claimant, tokenId, currentOwner));
    }

    /* standard mint function with access control ...*/ 

    function burn(uint256 tokenId) external virtual onlyRole(BURNER_ROLE) {
        address previousOwner = _update(address(0), tokenId, _msgSender()); 
        if (previousOwner == address(0)) revert ERC721NonexistentToken(tokenId);
    }

    function _update(address to, uint256 tokenId, address auth) internal virtual override returns(address) {
        address from = _ownerOf(tokenId);

        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        if (from != address(0) && to != address(0)) { // Transfer
            _validateCorrectOwner(from, tokenId);
            require(!_frozenTokens[from][tokenId], ERC7943FrozenTokenId(from, tokenId));
            require(canTransfer(from, to, tokenId), "ERC7943: transfer not allowed");
        } else if (from == address(0)) { // Mint
            require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        } else { // Burn
            _excessFrozenUpdate(from, tokenId);
        } 

        return super._update(to, tokenId, auth);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, IERC165) returns (bool) {
        return interfaceId == type(IERC7943NonFungible).interfaceId ||
               super.supportsInterface(interfaceId);
    }
}

pragma solidity ^0.8.29;

/* required imports ... */

contract uRWA1155 is Context, ERC1155, AccessControlEnumerable, IERC7943MultiToken {

    /* same definitions, constructor and changeWhitelist function as before ...*/

    mapping(address user => mapping(uint256 tokenId => uint256 amount)) internal _frozenTokens;

    function canTransfer(address from, address to, uint256 tokenId, uint256 amount) public view virtual override returns (bool allowed) {
        if (balanceOf(from, tokenId) < _frozenTokens[from][tokenId]) return;
        if (balanceOf(from, tokenId) < amount) return;
        if (!isUserAllowed(from) || !isUserAllowed(to)) return;
        if (amount > balanceOf(from, tokenId) - _frozenTokens[from][tokenId]) return;
        allowed = true;
    }

    function isUserAllowed(address user) public view virtual override returns (bool allowed) {
        if (isWhitelisted[user]) allowed = true;        
    }

    function getFrozenTokens(address user, uint256 tokenId) external view returns (uint256 amount) {
        amount = _frozenTokens[user][tokenId];
    }

    function setFrozenTokens(address user, uint256 tokenId, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        _frozenTokens[user][tokenId] = amount;        
        emit Frozen(user, tokenId, amount);
    }

    function forcedTransfer(address from, address to, uint256 tokenId, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        require(isUserAllowed(to), ERC7943NotAllowedUser(to));

        // Reimplementing _safeTransferFrom to avoid the check on _update
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }

        _excessFrozenUpdate(from, tokenId, amount);

        uint256[] memory ids = new uint256[](1);
        uint256[] memory values = new uint256[](1);
        ids[0] = tokenId;
        values[0] = amount;

        super._update(from, to, ids, values);
        
        if (to != address(0)) {
            address operator = _msgSender();
            if (ids.length == 1) {
                uint256 id = ids[0];
                uint256 value = values[0];
                ERC1155Utils.checkOnERC1155Received(operator, from, to, id, value, "");
            } else {
                ERC1155Utils.checkOnERC1155BatchReceived(operator, from, to, ids, values, "");
            }
        } 

        emit ForcedTransfer(from, to, tokenId, amount);
    }

    function _excessFrozenUpdate(address user, uint256 tokenId, uint256 amount) internal {
        uint256 unfrozenBalance = _unfrozenBalance(user, tokenId);
        if(amount > unfrozenBalance && amount <= balanceOf(user, tokenId)) { 
            // Protect from underflow: if amount > balanceOf(user) the call will revert in super._update with insufficient balance error
            _frozenTokens[user][tokenId] -= amount - unfrozenBalance; // Reduce by excess amount
            emit Frozen(user, tokenId, _frozenTokens[user][tokenId]);
        }
    }

    /* standard mint and burn functions with access control ...*/ 

    function _unfrozenBalance(address user, uint256 tokenId) internal view returns(uint256 unfrozenBalance) {
        unfrozenBalance = balanceOf(user, tokenId) < _frozenTokens[user][tokenId] ? 0 : balanceOf(user, tokenId) - _frozenTokens[user][tokenId];
    }

    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual override {
        if (ids.length != values.length) {
            revert ERC1155InvalidArrayLength(ids.length, values.length);
        }

        if (from != address(0) && to != address(0)) { // Transfer
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 id = ids[i];
                uint256 value = values[i];

                require(value <= balanceOf(from, id), ERC1155InsufficientBalance(from, balanceOf(from, id), value, id));
                uint256 unfrozenBalance = _unfrozenBalance(from, id);
                require(value <= unfrozenBalance, ERC7943InsufficientUnfrozenBalance(from, id, value, unfrozenBalance));
                require(canTransfer(from, to, id, value), "ERC7943: transfer not allowed");
            }
        }

        if (from == address(0)) { // Mint 
            require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        } else if (to == address(0)) { // Burn
            for (uint256 j = 0; j < ids.length; ++j) {
                _excessFrozenUpdate(from, ids[j], values[j]);
            }
        }

        super._update(from, to, ids, values);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC1155, IERC165) returns (bool) {
        return interfaceId == type(IERC7943MultiToken).interfaceId ||
               super.supportsInterface(interfaceId);
    }
}