Todo.txt

// TODO: add share functionality means if there are more then 1 recipient


// update recipient
// fallback function

// store will on chain in encrypted form.

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

contract DigitalWill {
    struct UserInfo {
        address user;
        mapping(address => uint256) recipientBalances;
        address[] recipients;
        uint lastAction;
        uint256 balance;
    }
    mapping(address => UserInfo) public users;

    event UserAdded(
        address indexed user,
        address[] indexed recipients,
        uint256 balance
    );
    event UserRemoved(address indexed user);
    event Withdrawn(
        address indexed parent,
        address indexed recipient,
        uint256 balance
    );
    event RevertedToOwner(address indexed user, uint256 balance);
    event Pinged(address indexed user);

    function adduser(address[] memory _recipients) external payable {
        require(msg.value > 0, "You must send some Ether to deposit.");
        require(users[msg.sender].user == address(0), "User already exists");

        UserInfo storage userInfo = users[msg.sender];

        userInfo.user = msg.sender;
        userInfo.recipients = _recipients;
        userInfo.lastAction = block.timestamp;
        userInfo.balance = msg.value;

        uint256 recipientBalance = msg.value / _recipients.length;

        for (uint i = 0; i < _recipients.length; i++) {
            userInfo.recipientBalances[_recipients[i]] = recipientBalance;
        }

        emit UserAdded(msg.sender, _recipients, msg.value);
    }

    function withdraw(address parent) external {
        require(users[parent].user != address(0), "User does not exist");

        require(
            users[parent].user == parent && isRecipient(parent, msg.sender),
            "Invalid user or recipient"
        );

        require(
            (block.timestamp - users[parent].lastAction) >= 52 weeks,
            "Withdrawal not allowed yet"
        );

        uint256 recipientBalance = users[parent].recipientBalances[msg.sender];

        (bool success, ) = msg.sender.call{value: recipientBalance}("");

        require(success, "Transfer to recipient failed");

        emit Withdrawn(parent, msg.sender, recipientBalance);

        users[parent].balance -= recipientBalance;

        users[parent].recipientBalances[msg.sender] = 0;

        if (users[parent].balance == 0) {
            removeUser(parent);
        }
    }

    // add revert transection means it will transfer the amount back to the wallet.
    function revertToOwner() external {
        require(
            msg.sender == users[msg.sender].user,
            "Only owner can call this function"
        );

        (bool success, ) = users[msg.sender].user.call{
            value: users[msg.sender].balance
        }("");

        require(success, "Transfer to recipient failed");

        emit RevertedToOwner(msg.sender, users[msg.sender].balance);

        users[msg.sender].balance = 0;

        removeUser(msg.sender);
    }

    function ping() external {
        require(
            msg.sender == users[msg.sender].user,
            "Only the user can call this function"
        );

        users[msg.sender].lastAction = block.timestamp;

        emit Pinged(msg.sender);
    }

    // View function to return user info
    function getUserInfo(address _user) public view returns (UserInfo memory) {
        return users[_user];
    }

    function isRecipient(
        address _user,
        address _recipient
    ) public view returns (bool) {
        return users[_user].recipientBalances[_recipient] > 0;
    }

    function isUser(address _user) public view returns (bool) {
        return users[_user].user == _user;
    }

    function removeUser(address userAddress) internal {
        require(
            users[userAddress].balance == 0,
            " User can't be remvoed Because User has not withdrawn yet"
        );

        emit UserRemoved(userAddress);

        delete users[userAddress];
    }
}