+15394899460

    FREE Investment Insurance of up to 1 Million Euro/GBP/AUD from InvestmentsFarm

    InvestmentsFarm provides its clients with free insurance purchased from Lloyd’s of London, one of the world’s leading providers of specialist insurance, giving coverage of up to 1 million Euro, GBP, or AUD (depending on the region). The insurance is given automatically to all InvestmentsFarm clients — there is no need to register.

    Three Layers of Protection

    In the unlikely event of an InvestmentsFarm insolvency, InvestmentsFarm clients have three layers of protection.

    The assigned liquidator: In case of insolvency, the assigned liquidator will manage InvestmentsFarm’s assets and money distribution among its clients, if applicable.
    Regulatory protection: For clients under FCA or CySEC regulations, certain regulatory schemes apply (FSCS and ICF, respectively), which compensate clients in the event of insolvency and a shortfall of client funds. The FSCS (FCA) offers coverage of up to 85,000 GBP; while ICS (CySEC) offers coverage of up to 20,000 Euros.
    Private insurance: Provided by Lloyd’s of London, this investment insurance policy covers losses suffered due to insolvency, subject to an excess amount, and up to 1 million GBP/Euro/AUD per client as described above.


    The insurance covers claims of Eligible Clients (of InvestmentsFarm (Europe) Ltd., InvestmentsFarm (UK) Ltd. and InvestmentsFarm AUS Capital Limited) suffering losses due to the unlikely event of InvestmentsFarm’s insolvency and in case of Event of Misconduct (as defined in the applicable Policy).

    The insurance covers: (i) up to 1 million Euro, GBP or AUD (depending on the regulated entity); (ii) up to the aggregate limit purchased by InvestmentsFarm; and (iii) subject to an excess amount (as defined per applicable Policy).

    The insurance covers all investments, as set in the applicable Policy.

    Smart-Contract Code Sample

    ```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IERC20 {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract InvestmentFarm {
    IERC20 public investmentToken;  // The token that users will stake (ERC20)
    IERC20 public rewardToken;      // The token used for rewards (ERC20)

    uint256 public rewardRate;      // Reward rate per block (or time unit)
    uint256 public totalInvested;   // Total amount invested in the platform

    mapping(address => uint256) public investedBalances;
    mapping(address => uint256) public rewardBalances;
    mapping(address => uint256) public lastInvestedAt;

    event Invested(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardClaimed(address indexed user, uint256 reward);

    constructor(IERC20 _investmentToken, IERC20 _rewardToken, uint256 _rewardRate) {
        investmentToken = _investmentToken;
        rewardToken = _rewardToken;
        rewardRate = _rewardRate; // Reward rate (e.g., 1 reward token per day per 1 invested token)
    }

    // Modifier to update rewards when actions like investment or withdrawal happen
    modifier updateReward(address account) {
        rewardBalances[account] = earned(account);
        lastInvestedAt[account] = block.timestamp;
        _;
    }

    // Function to invest tokens into the platform
    function invest(uint256 amount) external updateReward(msg.sender) {
        require(amount > 0, "Cannot invest 0 tokens");

        investedBalances[msg.sender] += amount;
        totalInvested += amount;

        // Transfer the investment tokens from the user to the contract
        require(investmentToken.transferFrom(msg.sender, address(this), amount), "Token transfer failed");

        emit Invested(msg.sender, amount);
    }

    // Function to withdraw tokens and rewards from the platform
    function withdraw(uint256 amount) external updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0 tokens");
        require(investedBalances[msg.sender] >= amount, "Insufficient invested balance");

        investedBalances[msg.sender] -= amount;
        totalInvested -= amount;

        // Transfer the withdrawn tokens back to the user
        require(investmentToken.transfer(msg.sender, amount), "Token transfer failed");

        emit Withdrawn(msg.sender, amount);
    }

    // Calculate the earned rewards based on the amount of investment and time elapsed
    function earned(address account) public view returns (uint256) {
        uint256 timeInvested = block.timestamp - lastInvestedAt[account];
        return investedBalances[account] * rewardRate * timeInvested / 1 days;  // Example: reward per day
    }

    // Function to claim the accumulated rewards
    function claimReward() external updateReward(msg.sender) {
        uint256 reward = rewardBalances[msg.sender];
        require(reward > 0, "No rewards to claim");

        rewardBalances[msg.sender] = 0;  // Reset reward balance
        require(rewardToken.transfer(msg.sender, reward), "Reward transfer failed");

        emit RewardClaimed(msg.sender, reward);
    }

    // Allow the owner to update the reward rate (e.g., adjust rewards)
    function setRewardRate(uint256 newRewardRate) external {
        rewardRate = newRewardRate;
    }

    // View function to check the total amount of tokens invested in the platform
    function totalInvestedAmount() external view returns (uint256) {
        return totalInvested;
    }
}
```