smom-dbis-138/contracts/compliance/LegallyCompliantBase.sol

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

/**
 * @title LegallyCompliantBase
 * @notice Base contract for all legally compliant value transfer instruments
 * @dev Provides legal framework declarations, ISO standards compliance, ICC compliance,
 *      and exemption declarations for Travel Rules and regulatory compliance
 */
abstract contract LegallyCompliantBase is AccessControl {
    using Strings for uint256;

    // Legal Framework Version
    string public constant LEGAL_FRAMEWORK_VERSION = "1.0.0";
    
    // Legal Jurisdiction
    string public constant LEGAL_JURISDICTION = "International Private Law";
    
    // Dispute Resolution
    string public constant DISPUTE_RESOLUTION_MECHANISM = "ICC Arbitration (Paris)";
    
    // Service of Process Address
    string public constant SERVICE_OF_PROCESS_ADDRESS = "0x0000000000000000000000000000000000000000";
    
    // ISO Standards Compliance
    string public constant ISO_20022_COMPLIANCE = "ISO 20022 (Financial Messaging) - Supported via ISO20022Router";
    string public constant ISO_27001_COMPLIANCE = "ISO 27001 (Information Security) - Architectural Compliance";
    string public constant ISO_3166_COMPLIANCE = "ISO 3166 (Country Codes) - Supported";
    string public constant ISO_8601_COMPLIANCE = "ISO 8601 (Timestamps) - Supported";
    string public constant ISO_4217_COMPLIANCE = "ISO 4217 (Currency Codes) - Supported";
    
    // ICC Compliance
    string public constant ICC_UNIFORM_RULES_COMPLIANCE = "ICC Uniform Rules for Demand Guarantees (URDG 758) - Applicable by reference";
    string public constant ICC_ARBITRATION_SUPPORT = "ICC Arbitration Rules - Supported for dispute resolution";
    string public constant ICC_TRADE_TERMS_COMPLIANCE = "Incoterms 2020 - Applicable by reference";
    
    // Instrument Classification
    string public constant INSTRUMENT_CLASSIFICATION = "Private Digital Instrument of Value Transfer";
    
    // Transferability Statement
    string public constant TRANSFERABILITY_STATEMENT = "This instrument represents a transferable claim or value, subject to contract terms.";
    
    // Legal Enforceability
    string public constant LEGAL_ENFORCEABILITY_STATEMENT = "Enforceable under private international law principles and ICC arbitration.";
    
    // Travel Rules Exemption
    string public constant TRAVEL_RULE_EXEMPTION_STATEMENT = 
        "This contract is designed for private, peer-to-peer value transfer and is not intended to facilitate transactions subject to FATF Travel Rule (e.g., not a VASP, no originator/beneficiary data collection, no transaction monitoring, no reporting).";
    
    // Regulatory Exemption
    string public constant REGULATORY_EXEMPTION_STATEMENT = 
        "This contract is not intended to be a money transmission service, payment service, or regulated financial instrument. It operates as a private instrument of value transfer between consenting parties.";
    
    // Events
    event LegalNotice(bytes32 indexed noticeHash, string message, uint256 timestamp);
    event ValueTransferDeclared(
        address indexed from,
        address indexed to,
        uint256 value,
        bytes32 legalReferenceHash
    );
    event JurisdictionDeclared(string jurisdiction, uint256 timestamp);
    event DisputeResolutionMechanismSet(string mechanism, uint256 timestamp);
    
    /**
     * @notice Constructor
     * @param admin Address that will receive DEFAULT_ADMIN_ROLE
     */
    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        emit JurisdictionDeclared(LEGAL_JURISDICTION, block.timestamp);
        emit DisputeResolutionMechanismSet(DISPUTE_RESOLUTION_MECHANISM, block.timestamp);
    }
    
    /**
     * @notice Record a legal notice
     * @param message The legal notice message
     */
    function recordLegalNotice(string calldata message) external onlyRole(DEFAULT_ADMIN_ROLE) {
        emit LegalNotice(
            keccak256(abi.encodePacked(message, block.timestamp)),
            message,
            block.timestamp
        );
    }
    
    /**
     * @notice Generate a legal reference hash for a value transfer
     * @param from Source address
     * @param to Destination address
     * @param value Transfer amount
     * @param additionalData Additional data for the transfer
     * @return legalReferenceHash The generated legal reference hash
     */
    function _generateLegalReferenceHash(
        address from,
        address to,
        uint256 value,
        bytes memory additionalData
    ) internal view returns (bytes32) {
        return keccak256(abi.encodePacked(
            block.timestamp,
            block.number,
            tx.origin,
            from,
            to,
            value,
            additionalData,
            LEGAL_FRAMEWORK_VERSION,
            LEGAL_JURISDICTION
        ));
    }
    
    /**
     * @notice Emit a compliant value transfer event
     * @param from Source address
     * @param to Destination address
     * @param value Transfer amount
     * @param legalReference Legal reference string
     * @param iso20022MessageId ISO 20022 message ID (if applicable)
     */
    function _emitCompliantValueTransfer(
        address from,
        address to,
        uint256 value,
        string memory legalReference,
        bytes32 iso20022MessageId
    ) internal {
        bytes32 legalRefHash = _generateLegalReferenceHash(
            from,
            to,
            value,
            abi.encodePacked(legalReference, iso20022MessageId)
        );
        
        emit ValueTransferDeclared(from, to, value, legalRefHash);
    }
}