ETHEREUM
+ IPFS

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

contract DocumentRegistry {
    event DocumentStored(address indexed owner, string cid, uint256 timestamp);

    struct Document {
        string cid;
        address owner;
        uint256 timestamp;
        string metadata;
    }

    mapping(bytes32 => Document) public documents;
    mapping(address => bytes32[]) public userDocuments;

    function storeDocument(string memory _cid, string memory _metadata) public {
        bytes32 docId = keccak256(abi.encodePacked(_cid, msg.sender, block.timestamp));

        documents[docId] = Document({
            cid: _cid,
            owner: msg.sender,
            timestamp: block.timestamp,
            metadata: _metadata
        });

        userDocuments[msg.sender].push(docId);
        emit DocumentStored(msg.sender, _cid, block.timestamp);
    }

    function getDocument(bytes32 _docId) public view returns (string memory, address, uint256, string memory) {
        Document memory doc = documents[_docId];
        return (doc.cid, doc.owner, doc.timestamp, doc.metadata);
    }

    function getUserDocuments(address _user) public view returns (bytes32[] memory) {
        return userDocuments[_user];
    }
}

import { create } from 'ipfs-http-client'
import { ethers } from 'ethers'

// 1. IPFS
const ipfs = create({ host: 'ipfs.infura.io', port: 5001, protocol: 'https' })

// 2. Ethereum
const provider = new ethers.BrowserProvider(window.ethereum)
const signer = await provider.getSigner()
const contract = new ethers.Contract(contractAddress, abi, signer)

// 3. Upload
async function uploadFile(file) {
  const added = await ipfs.add(file)
  const cid = added.path

  const tx = await contract.storeDocument(
    cid,
    JSON.stringify({ name: file.name, type: file.type, size: file.size })
  )
  await tx.wait()
  return cid
}

// 4. Query
async function getUserDocuments() {
  const address = await signer.getAddress()
  const docIds = await contract.getUserDocuments(address)
  const docs = []
  for (const docId of docIds) {
    const doc = await contract.getDocument(docId)
    docs.push({ id: docId, cid: doc.cid, owner: doc.owner, timestamp: doc.timestamp, metadata: JSON.parse(doc.metadata) })
  }
  return docs
}

import { useState } from 'react'
import { Upload, CheckCircle2, Loader } from 'lucide-react'

export default function FileUploader() {
  const [file, setFile] = useState(null)
  const [uploading, setUploading] = useState(false)
  const [cid, setCid] = useState('')
  const [txHash, setTxHash] = useState('')

  const handleUpload = async () => {
    if (!file) return
    setUploading(true)
    try {
      const added = await ipfs.add(file)
      setCid(added.path)
      const tx = await contract.storeDocument(added.path, JSON.stringify({ name: file.name }))
      const receipt = await tx.wait()
      setTxHash(receipt.hash)
    } finally {
      setUploading(false)
    }
  }

  return (
    <div className="p-6 bg-[#0A0A0A] border border-neutral-800 rounded-sm">
      <h3 className="text-lg font-bold mb-4">Upload to IPFS + Ethereum</h3>
      <input type="file" onChange={(e) => setFile(e.target.files[0])} />
      <button onClick={handleUpload} disabled={!file || uploading}>
        {uploading ? 'Uploading...' : 'Upload File'}
      </button>
      {cid && <div>{cid}</div>}
      {txHash && <div>{txHash}</div>}
    </div>
  )
}