First Smart Contract - SimpleContract and StorageFactory Example

FundMe.Sol

// SPDX-License-Identifier: MIT

// Smart contract that lets anyone deposit ETH into the contract
// Only the owner of the contract can withdraw the ETH
pragma solidity >=0.6.6 <0.9.0;

// Get the latest ETH/USD price from chainlink price feed
import "@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
import "@chainlink/contracts/src/v0.6/vendor/SafeMathChainlink.sol";

contract FundMe {
	// safe math library check uint256 for integer overflows
    using SafeMathChainlink for uint256;
    
    //mapping to store which address depositeded how much ETH
    mapping(address => uint256) public addressToAmountFunded;
    // array of addresses who deposited
    address[] public funders;
    //address of the owner (who deployed the contract)
    address public owner;
    
    // the first person to deploy the contract is
    // the owner
    constructor() public {
        owner = msg.sender;
    }
    
    function fund() public payable {
    	// 18 digit number to be compared with donated amount 
        uint256 minimumUSD = 50 * 10 ** 18;
        //is the donated amount less than 50USD?
        require(getConversionRate(msg.value) >= minimumUSD, "You need to spend more ETH!");
        //if not, add to mapping and funders array
        addressToAmountFunded[msg.sender] += msg.value;
        funders.push(msg.sender);
    }
    
    //function to get the version of the chainlink pricefeed
    function getVersion() public view returns (uint256){
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0x8A753747A1Fa494EC906cE90E9f37563A8AF630e);
        return priceFeed.version();
    }
    
    function getPrice() public view returns(uint256){
        AggregatorV3Interface priceFeed = AggregatorV3Interface(0x8A753747A1Fa494EC906cE90E9f37563A8AF630e);
        (,int256 answer,,,) = priceFeed.latestRoundData();
         // ETH/USD rate in 18 digit 
         return uint256(answer * 10000000000);
    }
    
    // 1000000000
    function getConversionRate(uint256 ethAmount) public view returns (uint256){
        uint256 ethPrice = getPrice();
        uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1000000000000000000;
        // the actual ETH/USD conversation rate, after adjusting the extra 0s.
        return ethAmountInUsd;
    }
    
    //modifier: https://medium.com/coinmonks/solidity-tutorial-all-about-modifiers-a86cf81c14cb
    modifier onlyOwner {
    	//is the message sender owner of the contract?
        require(msg.sender == owner);
        
        _;
    }
    
    // onlyOwner modifer will first check the condition inside it 
    // and 
    // if true, withdraw function will be executed 
    function withdraw() payable onlyOwner public {
    
    	// If you are using version eight (v0.8) of chainlink aggregator interface,
	// you will need to change the code below to
	// payable(msg.sender).transfer(address(this).balance);
        msg.sender.transfer(address(this).balance);

        
        //iterate through all the mappings and make them 0
        //since all the deposited amount has been withdrawn
        for (uint256 funderIndex=0; funderIndex < funders.length; funderIndex++){
            address funder = funders[funderIndex];
            addressToAmountFunded[funder] = 0;
        }
        //funders array will be initialized to 0
        funders = new address[](0);
    }
}

SimpleContract.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;


contract SimpleStorage {
    uint amount;

    struct People {
        uint amount;
        string name;
    }

    People[] public people;
    mapping(string => uint) public user_balance;
    
    function deposit(uint _amount, string memory source_name, string memory target_name) public {
        user_balance[source_name] = user_balance[source_name] - _amount;
        user_balance[target_name] = user_balance[target_name] + _amount;
    }

    function get_amount(string memory user_name) public view returns(uint) {
        return user_balance[user_name];
    }

    function register_person(string memory _name) public {
        people.push(People({amount: 100, name: _name}));
        user_balance[_name] = 100;
    }
}

StorageFactory.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

import "./SimpleStorage.sol";

contract StorageFactory {

    SimpleStorage[] public simpleStorageArray;

    function createSimpleStorageContract() public {
        SimpleStorage simpleStorage = new SimpleStorage();
        simpleStorageArray.push(simpleStorage);
    }

    function addUserToContract(uint _simpleStorageIndex, string memory user_name) public {
        SimpleStorage simpleStorage = SimpleStorage(address(simpleStorageArray[_simpleStorageIndex]));
        simpleStorage.register_person(user_name);
    }

    function getAmountFromContract(uint _simpleStorageIndex, string memory user_name) public view returns(uint){
        SimpleStorage simpleStorage = SimpleStorage(address(simpleStorageArray[_simpleStorageIndex]));
        return simpleStorage.get_amount(user_name);
    }

    function depositAmount(uint _simpleStorageIndex, uint amount, string memory source_name, string memory target_name) public {
        SimpleStorage simpleStorage = SimpleStorage(address(simpleStorageArray[_simpleStorageIndex]));
        simpleStorage.deposit(amount, source_name, target_name);
    }
}