1. // SPDX-License-Identifier: MIT
2. pragma solidity ^0.8.0;
3.  
4. import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
5.  
6. contract NFTMarketplace is ERC721 {
7.     struct Transaction {
8.         uint256 chainId;
9.         string txHash;
10.         string email;
11.         string addressFrom;
12.         string addressTo;
13.         uint256 amount;
14.         uint256 timestamp;
15.         string contractAddress;
16.         string tokenId;
17.     }
18.  
19.     struct NftAsset {
20.         uint256 chainId;
21.         string contractAddress;
22.         string tokenId;
23.         string metadata;
24.         string name;
25.         string mediaUrl;
26.         string mediaType;
27.         string mediaFormat;
28.         string ownerAddress;
29.         string ownerEmail;
30.         string status;
31.         uint256 rentalExpiration;
32.     }
33.  
34.     mapping(uint256 => Transaction) public transactions;
35.     mapping(bytes32 => NftAsset) public nftAssets;
36.  
37.     function getRentalExpiration(uint256 chainId, string memory tokenId) external view returns (uint256) {
38.         bytes32 assetId = keccak256(abi.encodePacked(chainId, msg.sender, tokenId));
39.         return nftAssets[assetId].rentalExpiration;
40.     }
41.  
42.     event TransactionAdded(uint256 indexed chainId, string indexed txHash);
43.     event NftAssetAdded(uint256 indexed chainId, string indexed contractAddress, string indexed tokenId);
44.  
45.    
46.     constructor() ERC721("NFT Marketplace", "NFTM") {}
47.  
48.     function addTransaction(
49.         uint256 chainId,
50.         string memory txHash,
51.         string memory email,
52.         string memory addressFrom,
53.         string memory addressTo,
54.         uint256 amount,
55.         string memory contractAddress,
56.         string memory tokenId
57.     ) external {
58.         transactions[chainId] = Transaction(chainId, txHash, email, addressFrom, addressTo, amount, block.timestamp, contractAddress, tokenId);
59.         emit TransactionAdded(chainId, txHash);
60.     }
61.  
62.     function addNftAsset(
63.         uint256 chainId,
64.         string memory contractAddress,
65.         string memory tokenId,
66.         string memory metadata,
67.         string memory name,
68.         string memory mediaUrl,
69.         string memory mediaType,
70.         string memory mediaFormat,
71.         string memory ownerAddress,
72.         string memory ownerEmail,
73.         string memory status
74.     ) external {
75.         bytes32 assetId = keccak256(abi.encodePacked(chainId, contractAddress, tokenId));
76.         nftAssets[assetId] = NftAsset(chainId, contractAddress, tokenId, metadata, name, mediaUrl, mediaType, mediaFormat, ownerAddress, ownerEmail, status, block.timestamp);
77.         emit NftAssetAdded(chainId, contractAddress, tokenId);
78.     }
79.  
80.     function getTransaction(uint256 chainId, string calldata txHash) external view returns (
81.         string memory email,
82.         string memory addressFrom,
83.         string memory addressTo,
84.         uint256 amount,
85.         uint256 timestamp,
86.         string memory contractAddress,
87.         string memory tokenId
88.     ) {
89.         Transaction memory transaction = transactions[chainId];
90.         return (
91.             transaction.email,
92.             transaction.addressFrom,
93.             transaction.addressTo,
94.             transaction.amount,
95.             transaction.timestamp,
96.             transaction.contractAddress,
97.             transaction.tokenId
98.         );
99.     }
100.  
101.     function getNftAsset(uint256 chainId, string calldata contractAddress, string calldata tokenId) external view returns (
102.         string memory metadata,
103.         string memory name,
104.         string memory mediaUrl,
105.         string memory mediaType,
106.         string memory mediaFormat,
107.         string memory ownerAddress,
108.         string memory ownerEmail,
109.         string memory status
110.     ) {
111.         bytes32 assetId = keccak256(abi.encodePacked(chainId, contractAddress, tokenId));
112.         NftAsset memory nftAsset = nftAssets[assetId];
113.         return (
114.             nftAsset.metadata,
115.             nftAsset.name,
116.             nftAsset.mediaUrl,
117.             nftAsset.mediaType,
118.             nftAsset.mediaFormat,
119.             nftAsset.ownerAddress,
120.             nftAsset.ownerEmail,
121.             nftAsset.status
122.            
123.         );
124.     }
125.  
126.     function listForSale(uint256 chainId, string memory tokenId) external {
127.         bytes32 assetId = keccak256(abi.encodePacked(chainId, msg.sender, tokenId));
128.         require(bytes(nftAssets[assetId].status).length == 0 || keccak256(bytes(nftAssets[assetId].status)) == keccak256("Rented"), "NFT is already listed for sale or rent");
129.         nftAssets[assetId].status = "ForSale";
130.     }
131.  
132.     function buyNFT(uint256 chainId, string memory tokenId) external payable {
133.     bytes32 assetId = keccak256(abi.encodePacked(chainId, msg.sender, tokenId));
134.     require(keccak256(bytes(nftAssets[assetId].status)) == keccak256("ForSale"), "NFT is not for sale");
135.     address payable seller = payable(ownerOfAsset(chainId, tokenId));
136.     address payable buyer = payable(msg.sender);
137.     uint256 price = msg.value;
138.     uint256 salePrice = 100; // Example sale price, you can set your desired price here
139.     require(price >= salePrice, "Insufficient payment");
140.  
141.     // Convert tokenId to uint256
142.     uint256 tokenIdUint = uint256(keccak256(abi.encodePacked(tokenId)));
143.  
144.     // Transfer NFT ownership
145.     _transfer(seller, buyer, tokenIdUint);
146.  
147.     // Update NFT status
148.     nftAssets[assetId].status = "Sold";
149.  
150.     // Transfer payment to seller
151.     seller.transfer(price);
152.  
153.     // Emit event
154.     emit TransactionAdded(chainId, ""); // Add relevant transaction hash if available
155. }
156.  
157.  
158.     function rentNFT(uint256 chainId, string memory tokenId, uint256 duration) external payable {
159.     bytes32 assetId = keccak256(abi.encodePacked(chainId, msg.sender, tokenId));
160.     require(keccak256(bytes(nftAssets[assetId].status)) == keccak256("ForRent"), "NFT is not for rent");
161.     address payable owner = payable(ownerOfAsset(chainId, tokenId));
162.     address payable renter = payable(msg.sender);
163.     uint256 price = msg.value;
164.     uint256 rentPrice = 50; // Example rent price, you can set your desired price here
165.     require(price >= rentPrice, "Insufficient payment");
166.  
167.     // Convert tokenId to uint256
168.     uint256 tokenIdUint = uint256(keccak256(abi.encodePacked(tokenId)));
169.  
170.     // Transfer NFT ownership
171.     _transfer(owner, renter, tokenIdUint);
172.  
173.     // Update NFT status
174.     nftAssets[assetId].status = "Rented";
175.  
176.     // Set rental expiration
177.     nftAssets[assetId].rentalExpiration = block.timestamp + duration;
178.  
179.     // Transfer payment to owner
180.     owner.transfer(price);
181.  
182.     // Emit event
183.     emit TransactionAdded(chainId, ""); // Add relevant transaction hash if available
184. }
185.  
186.  
187.     function ownerOfAsset(uint256 chainId, string memory tokenId) private view returns (address) {
188.         bytes32 assetId = keccak256(abi.encodePacked(chainId, msg.sender, tokenId));
189.         address owner = ownerOf(uint256(keccak256(abi.encodePacked(chainId, tokenId))));
190.         require(owner != address(0), "Invalid owner address");
191.         return owner;
192.     }
193. }