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

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

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

/**
 * @title LegallyCompliantBaseV2
 * @notice Explicit-actor legal and audit metadata base for GRU c* V2 tokens.
 * @dev Replaces tx.origin-based attribution with explicit initiator/authorizer/executor fields.
 */
abstract contract LegallyCompliantBaseV2 is AccessControl {
    bytes32 public constant COMPLIANCE_ADMIN_ROLE = keccak256("COMPLIANCE_ADMIN_ROLE");

    string public constant LEGAL_FRAMEWORK_VERSION = "2.0.0";
    string public constant LEGAL_JURISDICTION = "International Private Law";
    string public constant DISPUTE_RESOLUTION_MECHANISM = "ICC Arbitration (Paris)";
    string public constant SERVICE_OF_PROCESS_ADDRESS = "0x0000000000000000000000000000000000000000";
    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";
    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";
    string public constant INSTRUMENT_CLASSIFICATION = "Private Digital Instrument of Value Transfer";
    string public constant TRANSFERABILITY_STATEMENT =
        "This instrument represents a transferable claim or value, subject to contract terms.";
    string public constant LEGAL_ENFORCEABILITY_STATEMENT =
        "Enforceable under private international law principles and ICC arbitration.";
    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).";
    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.";

    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);
    event CompliantOperationDeclared(
        bytes32 indexed operationType,
        address indexed initiator,
        address indexed authorizer,
        address executor,
        address from,
        address to,
        uint256 value,
        bytes32 reasonHash,
        bytes32 accountingRef,
        bytes32 messageCorrelationId,
        bytes32 legalReferenceHash
    );

    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(COMPLIANCE_ADMIN_ROLE, admin);
        emit JurisdictionDeclared(LEGAL_JURISDICTION, block.timestamp);
        emit DisputeResolutionMechanismSet(DISPUTE_RESOLUTION_MECHANISM, block.timestamp);
    }

    function recordLegalNotice(string calldata message) external onlyRole(COMPLIANCE_ADMIN_ROLE) {
        emit LegalNotice(keccak256(abi.encodePacked(message, block.timestamp, address(this))), message, block.timestamp);
    }

    function _generateLegalReferenceHashV2(
        bytes32 operationType,
        address initiator,
        address authorizer,
        address executor,
        address from,
        address to,
        uint256 value,
        bytes32 reasonHash,
        bytes32 accountingRef,
        bytes32 messageCorrelationId,
        bytes32 additionalDataHash
    ) internal view returns (bytes32) {
        return keccak256(
            abi.encode(
                operationType,
                initiator,
                authorizer,
                executor,
                from,
                to,
                value,
                reasonHash,
                accountingRef,
                messageCorrelationId,
                additionalDataHash,
                block.chainid,
                address(this),
                LEGAL_FRAMEWORK_VERSION,
                LEGAL_JURISDICTION
            )
        );
    }

    function _recordCompliantOperation(
        bytes32 operationType,
        address initiator,
        address authorizer,
        address executor,
        address from,
        address to,
        uint256 value,
        bytes32 reasonHash,
        bytes32 accountingRef,
        bytes32 messageCorrelationId,
        bytes32 additionalDataHash
    ) internal returns (bytes32 legalReferenceHash) {
        legalReferenceHash = _generateLegalReferenceHashV2(
            operationType,
            initiator,
            authorizer,
            executor,
            from,
            to,
            value,
            reasonHash,
            accountingRef,
            messageCorrelationId,
            additionalDataHash
        );

        emit CompliantOperationDeclared(
            operationType,
            initiator,
            authorizer,
            executor,
            from,
            to,
            value,
            reasonHash,
            accountingRef,
            messageCorrelationId,
            legalReferenceHash
        );

        if (from != address(0) && to != address(0)) {
            emit ValueTransferDeclared(from, to, value, legalReferenceHash);
        }
    }
}