SteleFundInfo

{{
  "language": "Solidity",
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 600
    },
    "viaIR": true,
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  },
  "sources": {
    "contracts/SteleFundInfo.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import './base/Token.sol';
import './interfaces/ISteleFundInfo.sol';

contract SteleFundInfo is Token, ISteleFundInfo {
  address public override owner;
  mapping(uint256 => address) public override manager;                    // manager[fundId]
  uint256 public override fundIdCount = 0;

  // Maximum funds per investor to prevent DoS attacks
  uint256 public constant MAX_FUNDS_PER_INVESTOR = 100;

  // Fund creation block mapping
  mapping(uint256 => uint256) public fundCreationBlock;                   // fundCreationBlock[fundId]

  // fundId
  mapping(address => uint256) public override managingFund;               // managingFund[manager]
  mapping(address => mapping(uint256 => uint256)) public investingFunds;  // investingFunds[investor][index]
  mapping(address => uint256) public investingFundCount;

  // Token
  mapping(uint256 => IToken.Token[]) public fundTokens;                        // fundTokens[fundId]
  mapping(uint256 => IToken.Token[]) public feeTokens;                         // feeTokens[fundId]

  // Investor Shares
  mapping(uint256 => mapping(address => uint256)) public investorShares;  // investorShares[fundId][investor]
  mapping(uint256 => uint256) public fundShares;                     // fundShares[fundId]

  modifier onlyOwner() {
    require(msg.sender == owner, 'NO');
    _;
  }

  constructor() {
    owner = msg.sender;
    emit InfoCreated();
  }

  function setOwner(address newOwner) external override onlyOwner {
    address oldOwner = owner;
    owner = newOwner;
    emit OwnerChanged(oldOwner, newOwner);
  }

  function getFundTokens(uint256 fundId) external override view returns (IToken.Token[] memory) {
    return fundTokens[fundId];
  }

  function getInvestorShare(uint256 fundId, address investor) external override view returns (uint256) {
    return investorShares[fundId][investor];
  }

  function getFundShare(uint256 fundId) external override view returns (uint256) {
    return fundShares[fundId];
  }
  
  function getFeeTokens(uint256 fundId) external override view returns (IToken.Token[] memory) {
    return feeTokens[fundId];
  }

  function getFundTokenAmount(uint256 fundId, address token) public override view returns (uint256) {
    IToken.Token[] memory tokens = fundTokens[fundId];
    for (uint256 i=0; i<tokens.length; i++) {
      if (tokens[i].token == token) {
        return tokens[i].amount;
      }
    }
    return 0;
  }

  function getFeeTokenAmount(uint256 fundId, address token) public override view returns (uint256) {
    IToken.Token[] memory tokens = feeTokens[fundId];
    for (uint256 i=0; i<tokens.length; i++) {
      if (tokens[i].token == token) {
        return tokens[i].amount;
      }
    }
    return 0;
  }
  
  function create() external override returns (uint256 fundId) {
    require(managingFund[msg.sender] == 0, 'EXIST');
    uint256 fundCount = investingFundCount[msg.sender];
    require(fundCount < MAX_FUNDS_PER_INVESTOR, 'MFR'); // Max Funds Reached
    fundId = ++fundIdCount;
    managingFund[msg.sender] = fundId;
    investingFunds[msg.sender][fundCount] = fundId;
    investingFundCount[msg.sender] += 1;
    manager[fundId] = msg.sender;
    fundCreationBlock[fundId] = block.number; // Store fund creation block
    emit Create(fundId, msg.sender);
  }

  function isJoined(address investor, uint256 fundId) public override view returns (bool) {
    uint256 fundCount = investingFundCount[investor];
    for (uint256 i=0; i<fundCount; i++) {
      if (fundId == investingFunds[investor][i]) {
        return true;
      }
    }
    return false;
  }

  function join(uint256 fundId) external override {
    require(fundId > 0 && fundId <= fundIdCount, 'FNE'); // Fund Not Exists
    require(manager[fundId] != address(0), 'NFM'); // No Fund Manager
    require(!isJoined(msg.sender, fundId), 'EXIST');
    uint256 fundCount = investingFundCount[msg.sender];
    require(fundCount < MAX_FUNDS_PER_INVESTOR, 'MFR'); // Max Funds Reached
    investingFunds[msg.sender][fundCount] = fundId;
    investingFundCount[msg.sender] += 1;
    emit Join(fundId, msg.sender);
  }

  function increaseShare(uint256 fundId, address investor, uint256 amount) external override onlyOwner returns (uint256, uint256) {
    investorShares[fundId][investor] += amount;
    fundShares[fundId] += amount;
    uint256 investorShare = investorShares[fundId][investor];
    uint256 fundShare = fundShares[fundId];
    return (investorShare, fundShare);
  }

  function decreaseShare(uint256 fundId, address investor, uint256 amount) external override onlyOwner returns (uint256, uint256) {
    require(investorShares[fundId][investor] >= amount, "IS");
    require(fundShares[fundId] >= amount, "ITS");

    investorShares[fundId][investor] -= amount;
    fundShares[fundId] -= amount;
    uint256 investorShare = investorShares[fundId][investor];
    uint256 fundShare = fundShares[fundId];
    return (investorShare, fundShare);
  }

  function increaseFundToken(uint256 fundId, address token, uint256 amount) external override onlyOwner {
    increaseToken(fundTokens[fundId], token, amount);
  }

  function decreaseFundToken(uint256 fundId, address token, uint256 amount) external override onlyOwner returns (bool) {
    return decreaseToken(fundTokens[fundId], token, amount);
  }

  function increaseFeeToken(uint256 fundId, address token, uint256 amount) external override onlyOwner {
    increaseToken(feeTokens[fundId], token, amount);
  }

  function decreaseFeeToken(uint256 fundId, address token, uint256 amount) external override onlyOwner returns (bool) {
    return decreaseToken(feeTokens[fundId], token, amount);
  }
}"
    },
    "contracts/interfaces/ISteleFundInfo.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import './IToken.sol';

interface ISteleFundInfo is IToken {
  event InfoCreated();
  event OwnerChanged(address owner, address newOwner);
  event Create(uint256 fundId, address indexed manager);
  event Join(uint256 fundId, address indexed investor);
 
  function owner() external view returns (address _owner);
  function manager(uint256 fundId) external view returns (address _manager);
  function managingFund(address _manager) external view returns (uint256 fundId);
  function fundIdCount() external view returns (uint256 fundCount);
  function fundCreationBlock(uint256 fundId) external view returns (uint256 creationBlock);

  function setOwner(address newOwner) external;
  function create() external returns (uint256 fundId);
  function isJoined(address investor, uint256 fundId) external view returns (bool);
  function join(uint256 fundId) external;

  function getFundTokens(uint256 fundId) external view returns (Token[] memory);
  function getFeeTokens(uint256 fundId) external view returns (Token[] memory);
  function getFundTokenAmount(uint256 fundId, address token) external view returns (uint256);
  function getFeeTokenAmount(uint256 fundId, address token) external view returns (uint256);
  function getFundShare(uint256 fundId) external view returns (uint256);
  function getInvestorShare(uint256 fundId, address investor) external view returns (uint256);

  function increaseFundToken(uint256 fundId, address token, uint256 amount) external;
  function decreaseFundToken(uint256 fundId, address token, uint256 amount) external returns (bool);
  function increaseShare(uint256 fundId, address investor, uint256 amount) external returns (uint256, uint256);
  function decreaseShare(uint256 fundId, address investor, uint256 amount) external returns (uint256, uint256);
  function increaseFeeToken(uint256 fundId, address token, uint256 amount) external;
  function decreaseFeeToken(uint256 fundId, address token, uint256 amount) external returns (bool);
}"
    },
    "contracts/base/Token.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import '../interfaces/IToken.sol';

abstract contract Token {

  function increaseToken(IToken.Token[] storage tokens, address token, uint256 amount) internal {
    bool isNewToken = true;
    for (uint256 i=0; i<tokens.length; i++) {
      if (tokens[i].token == token) {
        isNewToken = false;
        tokens[i].amount += amount;
        break;
      }
    }
    if (isNewToken) {
      tokens.push(IToken.Token(token, amount));
    }
  }

  function decreaseToken(IToken.Token[] storage tokens, address token, uint256 amount) internal returns (bool) {
    for (uint256 i=0; i<tokens.length; i++) {
      if (tokens[i].token == token) {
        require(tokens[i].amount >= amount, 'NET');
        tokens[i].amount -= amount;
        if (tokens[i].amount == 0) {
          uint256 lastIndex = tokens.length-1;
          address lastToken = tokens[lastIndex].token;
          uint256 lastTokenAmount = tokens[lastIndex].amount;
          tokens[i].token = lastToken;
          tokens[i].amount = lastTokenAmount;
          tokens.pop();
        }
        return true;
      }
    }
    return false;
  }
}"
    },
    "contracts/interfaces/IToken.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

interface IToken {
  struct Token {
    address token;
    uint256 amount;
  }
}"
    }
  }
}}