Deploy smart contracts

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
 
/**
 * @title UserData
 * @notice This contract manages user profiles through create, update, and delete operations.
 * It emits events for each operation to enable off-chain indexing and notifications.
 */
contract UserData {
 
    // ===================================================
    // Section 1: Structs
    // ===================================================
 
    /**
     * @notice Struct 1.1: Represents a user's profile.
     * @param name Full name of the user.
     * @param email Email address of the user.
     * @param age Age of the user.
     * @param country Country of residence.
     * @param isKYCApproved Boolean flag indicating if KYC has been approved.
     * @param isDeleted Boolean flag indicating if the profile is soft-deleted.
     */
    struct UserProfile {
        string name;
        string email;
        uint8 age;
        string country;
        bool isKYCApproved;
        bool isDeleted;
    }
 
    // ===================================================
    // Section 2: Storage
    // ===================================================
 
    /**
     * @notice Storage 2.1: Mapping from a unique user ID to a user profile.
     */
    mapping(uint256 => UserProfile) public profiles;
 
    // ===================================================
    // Section 3: Events
    // ===================================================
 
    /**
     * @notice Event 3.1: Emitted when a new profile is created.
     * @dev Emits full profile details for indexing by off-chain systems.
     * @param userId The unique identifier for the user.
     * @param name The user's full name.
     * @param email The user's email address.
     * @param age The user's age.
     * @param country The user's country of residence.
     * @param isKYCApproved Whether the user is KYC approved.
     */
    event ProfileCreated(
        uint256 indexed userId,
        string name,
        string email,
        uint8 age,
        string country,
        bool isKYCApproved
    );
 
    /**
     * @notice Event 3.2: Emitted when an existing profile is updated.
     * @dev Emits updated profile details for indexing by off-chain systems.
     * @param userId The unique identifier for the user.
     * @param name The updated full name.
     * @param email The updated email address.
     * @param age The updated age.
     * @param country The updated country.
     * @param isKYCApproved The updated KYC approval status.
     */
    event ProfileUpdated(
        uint256 indexed userId,
        string name,
        string email,
        uint8 age,
        string country,
        bool isKYCApproved
    );
 
    /**
     * @notice Event 3.3: Emitted when a profile is soft-deleted.
     * @param userId The unique identifier for the user.
     */
    event ProfileDeleted(uint256 indexed userId);
 
    // ===================================================
    // Section 4: Functions
    // ===================================================
 
    /**
     * @notice Function 4.1: Creates a new user profile.
     * @dev The function reverts if a profile already exists for the given userId (unless it's soft-deleted).
     * @param userId Unique identifier for the user.
     * @param name The user's full name.
     * @param email The user's email address.
     * @param age The user's age.
     * @param country The user's country of residence.
     * @param isKYCApproved Boolean flag indicating if KYC is approved.
     */
    function createProfile(
        uint256 userId,
        string memory name,
        string memory email,
        uint8 age,
        string memory country,
        bool isKYCApproved
    ) public {
        // 4.1.1 Allow creation if profile is soft-deleted or does not exist (empty name indicates non-existence)
        require(
            profiles[userId].isDeleted || bytes(profiles[userId].name).length == 0,
            "Profile already exists"
        );
 
        // 4.1.2 Create and store the new profile
        profiles[userId] = UserProfile({
            name: name,
            email: email,
            age: age,
            country: country,
            isKYCApproved: isKYCApproved,
            isDeleted: false
        });
 
        // 4.1.3 Emit full profile data so off-chain indexers like The Graph can index it
        emit ProfileCreated(userId, name, email, age, country, isKYCApproved);
    }
 
    /**
     * @notice Function 4.2: Updates an existing user profile.
     * @dev Reverts if the profile does not exist or has been soft-deleted.
     * @param userId Unique identifier for the user.
     * @param name New full name for the user.
     * @param email New email address for the user.
     * @param age New age for the user.
     * @param country New country of residence for the user.
     * @param isKYCApproved New KYC approval status.
     */
    function updateProfile(
        uint256 userId,
        string memory name,
        string memory email,
        uint8 age,
        string memory country,
        bool isKYCApproved
    ) public {
        // 4.2.1 Ensure the profile exists and is not deleted
        require(
            bytes(profiles[userId].name).length > 0 && !profiles[userId].isDeleted,
            "Profile does not exist or has been deleted"
        );
 
        // 4.2.2 Update the profile with new details
        profiles[userId] = UserProfile({
            name: name,
            email: email,
            age: age,
            country: country,
            isKYCApproved: isKYCApproved,
            isDeleted: false
        });
 
        // 4.2.3 Emit updated full profile data so subgraph can index changes
        emit ProfileUpdated(userId, name, email, age, country, isKYCApproved);
    }
 
    /**
     * @notice Function 4.3: Retrieves the profile of a given user.
     * @dev Reverts if the profile has been soft-deleted or does not exist.
     * @param userId Unique identifier for the user.
     * @return The UserProfile struct containing the user's information.
     */
    function getProfile(uint256 userId) public view returns (UserData.UserProfile memory) {
        // 4.3.1 Ensure the profile exists (not soft-deleted)
        require(!profiles[userId].isDeleted, "Profile not found or has been deleted");
        return profiles[userId];
    }
 
    /**
     * @notice Function 4.4: Soft-deletes a user profile.
     * @dev Marks a profile as deleted without removing its data, reverting if the profile doesn't exist or is already deleted.
     * @param userId Unique identifier for the user.
     */
    function deleteProfile(uint256 userId) public {
        // 4.4.1 Ensure that the profile exists and is not already deleted
        require(
            bytes(profiles[userId].name).length > 0 && !profiles[userId].isDeleted,
            "Profile already deleted or doesn't exist"
        );
 
        // 4.4.2 Soft-delete the profile by setting its isDeleted flag to true
        profiles[userId].isDeleted = true;
 
        // 4.4.3 Emit event to notify that the profile has been deleted
        emit ProfileDeleted(userId);
    }
}

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
 
const UserDataModule = buildModule("UserDataModule", (m) => {
  const userdata = m.contract("UserData");
  return { userdata };
});
 
export default UserDataModule;

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;
 
import "forge-std/Test.sol";
import "../contracts/UserData.sol"; // Adjust the import path if needed
 
contract UserTest is Test {
    UserData public user;
 
    function setUp() public {
        // Deploy the contract before each test
        user = new UserData();
    }
 
    function testCreateProfile() public {
        // Call createProfile
        user.createProfile(1, "Alice", "[email protected]", 30, "USA", true);
 
        // Fetch the profile struct
        UserData.UserProfile memory profile = user.getProfile(1);
 
        // Assert values match what we set
        assertEq(profile.name, "Alice");
        assertEq(profile.email, "[email protected]");
        assertEq(profile.age, 30);
        assertEq(profile.country, "USA");
        assertEq(profile.isKYCApproved, true);
        assertEq(profile.isDeleted, false);
    }
 
    function testUpdateProfile() public {
        // First create a profile
        user.createProfile(2, "Bob", "[email protected]", 28, "UK", false);
 
        // Update profile with new values
        user.updateProfile(2, "Bob Updated", "[email protected]", 29, "Canada", true);
 
        // Fetch the updated profile
        UserData.UserProfile memory profile = user.getProfile(2);
 
        // Assert updated values
        assertEq(profile.name, "Bob Updated");
        assertEq(profile.email, "[email protected]");
        assertEq(profile.age, 29);
        assertEq(profile.country, "Canada");
        assertEq(profile.isKYCApproved, true);
        assertEq(profile.isDeleted, false);
    }
 
    function testDeleteProfile() public {
        // Create and delete a profile
        user.createProfile(3, "Charlie", "[email protected]", 25, "Germany", true);
        user.deleteProfile(3);
 
        // Expect revert on reading a deleted profile
        vm.expectRevert("Profile not found or has been deleted");
        user.getProfile(3);
    }
 
    function testCannotCreateDuplicateProfile() public {
        // Create the profile
        user.createProfile(4, "Dan", "[email protected]", 35, "India", false);
 
        // Attempt to create with the same ID again should revert
        vm.expectRevert("Profile already exists");
        user.createProfile(4, "DanAgain", "[email protected]", 36, "India", true);
    }
 
    function testCannotUpdateNonexistentProfile() public {
        // Try to update a profile that was never created
        vm.expectRevert("Profile does not exist or has been deleted");
        user.updateProfile(5, "Eve", "[email protected]", 31, "Brazil", true);
    }
 
    function testCannotDeleteNonexistentProfile() public {
        // Try to delete a profile that doesn't exist
        vm.expectRevert("Profile already deleted or doesn't exist");
        user.deleteProfile(6);
    }
 
    function testSoftDeletedCannotBeRead() public {
        // Create and delete a profile
        user.createProfile(7, "Zed", "[email protected]", 44, "Japan", true);
        user.deleteProfile(7);
 
        // Trying to read it should revert
        vm.expectRevert("Profile not found or has been deleted");
        user.getProfile(7);
    }
 
    function testRecreateAfterSoftDelete() public {
        // Create and delete a profile
        user.createProfile(8, "Tom", "[email protected]", 20, "Italy", true);
        user.deleteProfile(8);
 
        // Re-create it with new data (allowed due to soft-deletion)
        user.createProfile(8, "TomNew", "[email protected]", 21, "Spain", false);
 
        UserData.UserProfile memory profile = user.getProfile(8);
 
        assertEq(profile.name, "TomNew");
        assertEq(profile.email, "[email protected]");
        assertEq(profile.age, 21);
        assertEq(profile.country, "Spain");
        assertEq(profile.isKYCApproved, false);
        assertEq(profile.isDeleted, false);
    }
}

import { loadFixture } from "@nomicfoundation/hardhat-toolbox-viem/network-helpers";
import { expect } from "chai";
import hre from "hardhat";
 
// Describe our test suite for the UserData contract
describe("UserData", function () {
  // deployUserFixture deploys the UserData contract using viem and returns the deployed contract instance
  // along with the address of the first wallet client.
  async function deployUserFixture() {
    // Deploy the UserData contract using viem.
    // The contract name ("UserData") must match your contract's name.
    const userContract = await hre.viem.deployContract("UserData");
    // Get the first wallet client's account address to use as a signer for simulate calls.
    const account = (await hre.viem.getWalletClients())[0].account.address;
    return { userContract, account };
  }
 
  // Define a sample user profile object for tests.
  const sampleProfile = {
    userId: 1n, // BigInt literal is used for user IDs
    name: "Alice",
    email: "[email protected]",
    age: 30,
    country: "Wonderland",
    isKYCApproved: true,
  };
 
  // -------------------------------
  // Tests for createProfile functionality
  // -------------------------------
  describe("createProfile", function () {
    it("should create a new profile", async function () {
      // Use loadFixture to deploy a fresh instance of the contract.
      const { userContract } = await loadFixture(deployUserFixture);
 
      // Call the write method for createProfile with sampleProfile data.
      await userContract.write.createProfile([
        sampleProfile.userId,
        sampleProfile.name,
        sampleProfile.email,
        sampleProfile.age,
        sampleProfile.country,
        sampleProfile.isKYCApproved,
      ]);
 
      // Read the stored profile from the contract using the read method.
      const profile = (await userContract.read.getProfile([
        sampleProfile.userId,
      ])) as {
        name: string;
        email: string;
        age: number;
        country: string;
        isKYCApproved: boolean;
      };
 
      // Assert that the returned profile data matches our input values.
      expect(profile.name).to.equal(sampleProfile.name);
      expect(profile.email).to.equal(sampleProfile.email);
    });
 
    it("should not allow duplicate profile creation", async function () {
      // Deploy a fresh instance using the fixture.
      const { userContract, account } = await loadFixture(deployUserFixture);
 
      // Create a profile with the sample data.
      await userContract.write.createProfile([
        sampleProfile.userId,
        sampleProfile.name,
        sampleProfile.email,
        sampleProfile.age,
        sampleProfile.country,
        sampleProfile.isKYCApproved,
      ]);
 
      // Attempt to simulate (dry-run) creating a duplicate profile.
      // We use simulate.createProfile so that no state change occurs if it fails.
      try {
        await userContract.simulate.createProfile(
          [sampleProfile.userId, "Bob", "[email protected]", 25, "Utopia", false],
          { account }
        );
        // If no error is thrown, the test should fail.
        expect.fail("Expected simulate.createProfile to revert");
      } catch (err: any) {
        // Check that an error is thrown.
        expect(err).to.exist;
      }
    });
  });
 
  // -------------------------------
  // Tests for updateProfile functionality
  // -------------------------------
  describe("updateProfile", function () {
    it("should update an existing profile", async function () {
      // Deploy a fresh instance.
      const { userContract } = await loadFixture(deployUserFixture);
 
      // First, create the profile using the sample data.
      await userContract.write.createProfile([
        sampleProfile.userId,
        sampleProfile.name,
        sampleProfile.email,
        sampleProfile.age,
        sampleProfile.country,
        sampleProfile.isKYCApproved,
      ]);
 
      // Update the profile's email using updateProfile.
      await userContract.write.updateProfile([
        sampleProfile.userId,
        sampleProfile.name,
        "[email protected]", // new email value
        sampleProfile.age,
        sampleProfile.country,
        sampleProfile.isKYCApproved,
      ]);
 
      // Read the updated profile.
      const updated = (await userContract.read.getProfile([
        sampleProfile.userId,
      ])) as {
        name: string;
        email: string;
        age: number;
        country: string;
        isKYCApproved: boolean;
      };
 
      // Verify that the email was updated.
      expect(updated.email).to.equal("[email protected]");
    });
 
    it("should fail to update non-existent profile", async function () {
      // Deploy a fresh instance.
      const { userContract, account } = await loadFixture(deployUserFixture);
 
      // Attempt to simulate updating a profile that does not exist.
      try {
        await userContract.simulate.updateProfile(
          [999n, "Ghost", "[email protected]", 99, "Nowhere", false],
          { account }
        );
        expect.fail("Expected simulate.updateProfile to revert");
      } catch (err: any) {
        // Just ensure that an error was thrown.
        expect(err).to.exist;
      }
    });
  });
 
  // -------------------------------
  // Tests for deleteProfile functionality
  // -------------------------------
  describe("deleteProfile", function () {
    it("should soft delete a profile", async function () {
      // Deploy a fresh instance.
      const { userContract } = await loadFixture(deployUserFixture);
 
      // Create the profile.
      await userContract.write.createProfile([
        sampleProfile.userId,
        sampleProfile.name,
        sampleProfile.email,
        sampleProfile.age,
        sampleProfile.country,
        sampleProfile.isKYCApproved,
      ]);
 
      // Delete the profile.
      await userContract.write.deleteProfile([sampleProfile.userId]);
 
      // Try reading the profile, expecting it to revert.
      try {
        await userContract.read.getProfile([sampleProfile.userId]);
        expect.fail("Expected getProfile to revert");
      } catch (err: any) {
        expect(err).to.exist;
      }
    });
 
    it("should fail to delete a non-existent profile", async function () {
      // Deploy a fresh instance.
      const { userContract, account } = await loadFixture(deployUserFixture);
 
      // Attempt to simulate deleting a profile that does not exist.
      try {
        await userContract.simulate.deleteProfile([123n], { account });
        expect.fail("Expected simulate.deleteProfile to revert");
      } catch (err: any) {
        expect(err).to.exist;
      }
    });
  });
});