// SPDX-License-Identifier: MIT
      pragma solidity ^0.8.19;
      
      interface IERC721 {
          function ownerOf(uint256 tokenId) external view returns (address);
          function transferFrom(address from, address to, uint256 tokenId) external;
      }
      
      /// @title NFT Ownership Verification and Secure Transfer Contract
      /// @dev Enables verification and secure peer-to-peer transfers
      contract NFTOwnershipVerifier {
          event OwnershipVerified(address indexed user, uint256 indexed tokenId);
          event NFTTransferred(address indexed from, address indexed to, uint256 indexed tokenId);
      
          /// @notice Verifies if a user owns a specific NFT
          /// @param nftContract Address of the ERC-721 contract
          /// @param tokenId ID of the NFT
          /// @param user Address of the potential owner
          /// @return bool Whether the user owns the token
          function verifyOwnership(address nftContract, uint256 tokenId, address user)
              external
              view
              returns (bool)
          {
              IERC721 nft = IERC721(nftContract);
              bool isOwner = nft.ownerOf(tokenId) == user;
              if (isOwner) {
                  emit OwnershipVerified(user, tokenId);
              }
              return isOwner;
          }
      
          /// @notice Securely transfers an NFT between two users
          /// @param nftContract Address of the ERC-721 contract
          /// @param tokenId ID of the NFT
          /// @param from Current owner of the NFT
          /// @param to New recipient of the NFT
          function secureTransfer(
              address nftContract,
              uint256 tokenId,
              address from,
              address to
          ) external {
              IERC721 nft = IERC721(nftContract);
              require(nft.ownerOf(tokenId) == from, "Sender does not own the NFT");
              nft.transferFrom(from, to, tokenId);
              emit NFTTransferred(from, to, tokenId);
          }
      }
                 

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

/// @title Web3 Ownership Smart Contract
/// @dev Enables ownership management and secure asset transfers
contract Web3Ownership {
address public owner;
mapping(address => bool) public authorizedUsers;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event UserAuthorized(address indexed user);
event UserRevoked(address indexed user);

constructor() {
owner = msg.sender;
}

/// @notice Transfers ownership to a new address
/// @param newOwner Address of the new contract owner
function transferOwnership(address newOwner) public {
require(msg.sender == owner, "Not the contract owner");
require(newOwner != address(0), "Invalid new owner");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}

/// @notice Authorizes a new user for specific operations
/// @param user Address to be authorized
function authorizeUser(address user) public {
require(msg.sender == owner, "Only the owner can authorize");
authorizedUsers[user] = true;
emit UserAuthorized(user);
}

/// @notice Revokes authorization from a user
/// @param user Address to be revoked
function revokeUser(address user) public {
require(msg.sender == owner, "Only the owner can revoke access");
authorizedUsers[user] = false;
emit UserRevoked(user);
}

/// @notice Checks if an address is authorized
/// @param user Address to check
function isAuthorized(address user) public view returns (bool) {
return authorizedUsers[user];
}
}