🧩 Day 16 of #30DaysOfSolidity — Building a Modular Profile System for Web3 Games with `delegatecall`

day16-modular-profile/
├── foundry.toml
├── lib/
│   └── forge-std/                 # Foundry standard library
├── script/
│   └── Deploy.s.sol               # Deployment script
├── src/
│   ├── CoreProfile.sol            # Main contract
│   ├── IPlugin.sol                # Plugin interface
│   └── plugins/
│       └── AchievementPlugin.sol  # Example plugin contract
├── test/
│   └── CoreProfile.t.sol          # (Optional) Foundry tests
└── frontend/                      # React + Ethers.js frontend (optional)
    ├── package.json
    ├── src/
    │   └── App.jsx
    └── public/
        └── index.html

# Create new foundry project
forge init day16-modular-profile

cd day16-modular-profile

# Create plugin and script folders
mkdir -p src/plugins script

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

interface IPlugin {
    function execute(bytes calldata data) external;
}

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

import "./IPlugin.sol";

contract CoreProfile {
    struct Profile {
        string name;
        string avatar;
        mapping(address => bool) activePlugins;
    }

    mapping(address => Profile) private profiles;
    mapping(string => address) public pluginRegistry;

    event ProfileCreated(address indexed user, string name, string avatar);
    event PluginRegistered(string name, address plugin);
    event PluginActivated(address indexed user, string plugin);
    event PluginExecuted(address indexed user, string plugin, bytes data);

    modifier onlyRegisteredPlugin(string memory _plugin) {
        require(pluginRegistry[_plugin] != address(0), "Plugin not registered");
        _;
    }

    /// @notice Create player profile
    function createProfile(string calldata _name, string calldata _avatar) external {
        Profile storage p = profiles[msg.sender];
        p.name = _name;
        p.avatar = _avatar;
        emit ProfileCreated(msg.sender, _name, _avatar);
    }

    /// @notice Register new plugin
    function registerPlugin(string calldata _name, address _plugin) external {
        pluginRegistry[_name] = _plugin;
        emit PluginRegistered(_name, _plugin);
    }

    /// @notice Activate plugin for user
    function activatePlugin(string calldata _pluginName) external onlyRegisteredPlugin(_pluginName) {
        Profile storage p = profiles[msg.sender];
        p.activePlugins[pluginRegistry[_pluginName]] = true;
        emit PluginActivated(msg.sender, _pluginName);
    }

    /// @notice Execute plugin logic via delegatecall
    function executePlugin(string calldata _pluginName, bytes calldata data)
        external
        onlyRegisteredPlugin(_pluginName)
    {
        address pluginAddr = pluginRegistry[_pluginName];
        Profile storage p = profiles[msg.sender];
        require(p.activePlugins[pluginAddr], "Plugin not active");

        (bool success, ) = pluginAddr.delegatecall(
            abi.encodeWithSelector(IPlugin.execute.selector, data)
        );
        require(success, "Delegatecall failed");

        emit PluginExecuted(msg.sender, _pluginName, data);
    }

    /// @notice Get player profile info
    function getProfile(address _user) external view returns (string memory, string memory) {
        Profile storage p = profiles[_user];
        return (p.name, p.avatar);
    }
}

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

import "../IPlugin.sol";

contract AchievementPlugin is IPlugin {
    mapping(address => uint256) public achievements;

    event AchievementUnlocked(address indexed player, string achievement);

    function execute(bytes calldata data) external override {
        (string memory achievement) = abi.decode(data, (string));
        achievements[msg.sender] += 1;
        emit AchievementUnlocked(msg.sender, achievement);
    }
}

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

import "forge-std/Script.sol";
import "../src/CoreProfile.sol";
import "../src/plugins/AchievementPlugin.sol";

contract Deploy is Script {
    function run() external {
        vm.startBroadcast();

        CoreProfile core = new CoreProfile();
        AchievementPlugin plugin = new AchievementPlugin();

        core.registerPlugin("Achievements", address(plugin));

        vm.stopBroadcast();
    }
}

# Compile contracts
forge build

# Run deployment
forge script script/Deploy.s.sol --rpc-url <YOUR_RPC_URL> --private-key <PRIVATE_KEY> --broadcast

import { useState } from "react";
import { ethers } from "ethers";
import CoreProfileAbi from "./CoreProfile.json";

const CORE_PROFILE = "0xYourDeployedAddress";

function App() {
  const [name, setName] = useState("");
  const [avatar, setAvatar] = useState("");
  const [achievement, setAchievement] = useState("");

  async function getContract() {
    const provider = new ethers.BrowserProvider(window.ethereum);
    const signer = await provider.getSigner();
    return new ethers.Contract(CORE_PROFILE, CoreProfileAbi, signer);
  }

  async function createProfile() {
    const contract = await getContract();
    await contract.createProfile(name, avatar);
    alert("Profile Created!");
  }

  async function activatePlugin() {
    const contract = await getContract();
    await contract.activatePlugin("Achievements");
    alert("Plugin Activated!");
  }

  async function unlockAchievement() {
    const contract = await getContract();
    const data = ethers.AbiCoder.defaultAbiCoder().encode(["string"], [achievement]);
    await contract.executePlugin("Achievements", data);
    alert("Achievement Unlocked!");
  }

  return (
    <div className="p-8 max-w-lg mx-auto text-center">
      <h1 className="text-2xl font-bold mb-4">Web3 Modular Profile</h1>

      <input placeholder="Name" onChange={e => setName(e.target.value)} className="border p-2 mb-2" />
      <input placeholder="Avatar URL" onChange={e => setAvatar(e.target.value)} className="border p-2 mb-2" />
      <button onClick={createProfile} className="bg-blue-500 text-white px-4 py-2 rounded">Create Profile</button>

      <hr className="my-4" />
      <button onClick={activatePlugin} className="bg-green-500 text-white px-4 py-2 rounded">Activate Plugin</button>

      <hr className="my-4" />
      <input placeholder="Achievement" onChange={e => setAchievement(e.target.value)} className="border p-2 mb-2" />
      <button onClick={unlockAchievement} className="bg-purple-500 text-white px-4 py-2 rounded">Unlock</button>
    </div>
  );
}

export default App;