Unlimited Revenue

Flexible income generation system allows you to increase your individual profit percentage every day.

Safety of Funds

The function of repudiation of property ensures the absolute security of all participants' funds.

Detailed Statistics

Watch the growth of your balance in the online mode in your Personal account. Now even more statistics!

Ethereum Platform

Blockchain decentralized technology ensures complete transaction security and transparency.

Lifetime income without limits!

The "Contractum" Marketing

Main profitability:

4% daily for lifetime

Every minute the smart contract calculates your profit in relation to all deposits you have made.
For approximately 1 minute, 0.0026% is charged, for 1 hour - 0.16%, for a day 4%. You can withdraw the profit at any time.
Individual HOLD-bonus:

+0.1% to your profit for every day without a payment request

A smart contract calculates the time since your deposit, or the last payment ordered. If you did not order the payment, you will be charged an additional +0.1% daily.
Every day this percentage is summed up: in 24 hours +0.1%, after 48 hours +0.2%, after 72 hours +0.3% and so on to infinity.
General project bonus:

+0.1% to your profit for every 100 ETH on the Contractum smart contract balance

The smart contract checks your current balance, and adds to your profit an additional +0.1% for every 100 ETH on its balance. For example, if a smart contract has a balance of 1600 ETH, then you get a bonus to your profit +1.6%.
Transaction Secured and Transparent
Refraining from owning a smart contract
Open source code without backdoors and bugs
Independent audits successfully completed:
  • We work only with Ethereum
  • Minimum deposit: 0.01 ETH
  • Deposit body is not refundable
  • Accruals every minute
  • Withdrawal at any time
  • There is no minimum amount to withdraw
  • Recommended GAS: 200 000
"Contractum" smart contract code is:
pragma solidity 0.4.25;

/**
 *
 * Contractum.cc
 *
 * Get 4% (and more) daily for lifetime!
 *
 * You get +0.1% to your profit for each 100 ETH on smartcontract balance (f.e., 5.6% daily while smartcontract balance is among 1600-1700 ETH etc.).
 *
 * You get +0.1% to your profit for each full 24 hours when you not withdrawn your income!
 *
 * 5% for referral program (use Add Data field and fill it with ETH-address of your upline when you create your deposit).
 *
 * Minimum invest amount is 0.01 ETH.
 * Use 200000 of Gas limit for your transactions.
 *
 * Payments: 88%
 * Advertising: 7%
 * Admin: 5%
 *
 */

contract Contractum {
    using SafeMath for uint256;

    mapping (address => uint256) public userInvested;
    mapping (address => uint256) public userWithdrawn;
    mapping (address => uint256) public userLastOperationTime;
    mapping (address => uint256) public userLastWithdrawTime;

    uint256 constant public INVEST_MIN_AMOUNT = 10 finney;      // 0.01 ETH
    uint256 constant public BASE_PERCENT = 40;                  // 4%
    uint256 constant public REFERRAL_PERCENT = 50;              // 5%
    uint256 constant public MARKETING_FEE = 70;                 // 7%
    uint256 constant public PROJECT_FEE = 50;                   // 5%
    uint256 constant public PERCENTS_DIVIDER = 1000;            // 100%
    uint256 constant public CONTRACT_BALANCE_STEP = 100 ether;  // 100 ETH
    uint256 constant public TIME_STEP = 1 days;                 // 86400 seconds

    uint256 public totalInvested = 0;
    uint256 public totalWithdrawn = 0;

    address public marketingAddress = 0x9631Be3F285441Eb4d52480AAA227Fa9CdC75153;
    address public projectAddress = 0x53b9f206EabC211f1e60b3d98d532b819e182725;

    event addedInvest(address indexed user, uint256 amount);
    event payedDividends(address indexed user, uint256 dividend);
    event payedFees(address indexed user, uint256 amount);
    event payedReferrals(address indexed user, address indexed referrer, uint256 amount, uint256 refAmount);

    // function to get actual percent rate which depends on contract balance
    function getContractBalanceRate() public view returns (uint256) {
        uint256 contractBalance = address(this).balance;
        uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
        return BASE_PERCENT.add(contractBalancePercent);
    }

    // function to get actual user percent rate which depends on user last dividends payment
    function getUserPercentRate(address userAddress) public view returns (uint256) {
        uint256 contractBalanceRate = getContractBalanceRate();
        if (userInvested[userAddress] != 0) {
            uint256 timeMultiplier = now.sub(userLastWithdrawTime[userAddress]).div(TIME_STEP);
            return contractBalanceRate.add(timeMultiplier);
        } else {
            return contractBalanceRate;
        }
    }

    // function to get actual user dividends amount which depends on user percent rate
    function getUserDividends(address userAddress) public view returns (uint256) {
        uint256 userPercentRate = getUserPercentRate(userAddress);
        uint256 userPercents = userInvested[userAddress].mul(userPercentRate).div(PERCENTS_DIVIDER);
        uint256 timeDiff = now.sub(userLastOperationTime[userAddress]);
        uint256 userDividends = userPercents.mul(timeDiff).div(TIME_STEP);
        return userDividends;
    }

    // function to create new or add to user invest amount
    function addInvest() private {
        // update user timestamps if it is first user invest
        if (userInvested[msg.sender] == 0) {
            userLastOperationTime[msg.sender] = now;
            userLastWithdrawTime[msg.sender] = now;
        // pay dividends if user already made invest
        } else {
            payDividends();
        }

        // add to user deposit and total invested
        userInvested[msg.sender] += msg.value;
        emit addedInvest(msg.sender, msg.value);
        totalInvested = totalInvested.add(msg.value);

        // pay marketing and project fees
        uint256 marketingFee = msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
        uint256 projectFee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
        uint256 feeAmount = marketingFee.add(projectFee);
        marketingAddress.transfer(marketingFee);
        projectAddress.transfer(projectFee);
        emit payedFees(msg.sender, feeAmount);

        // pay ref amount to referrer
        address referrer = bytesToAddress(msg.data);
        if (referrer > 0x0 && referrer != msg.sender) {
            uint256 refAmount = msg.value.mul(REFERRAL_PERCENT).div(PERCENTS_DIVIDER);
            referrer.transfer(refAmount);
            emit payedReferrals(msg.sender, referrer, msg.value, refAmount);
        }
    }

    // function for pay dividends to user
    function payDividends() private {
        require(userInvested[msg.sender] != 0);

        uint256 contractBalance = address(this).balance;
        uint256 percentsAmount = getUserDividends(msg.sender);

        // pay percents amount if percents amount less than available contract balance
        if (contractBalance >= percentsAmount) {
            msg.sender.transfer(percentsAmount);
            userWithdrawn[msg.sender] += percentsAmount;
            emit payedDividends(msg.sender, percentsAmount);
            totalWithdrawn = totalWithdrawn.add(percentsAmount);
        // pay all contract balance if percents amount more than available contract balance
        } else {
            msg.sender.transfer(contractBalance);
            userWithdrawn[msg.sender] += contractBalance;
            emit payedDividends(msg.sender, contractBalance);
            totalWithdrawn = totalWithdrawn.add(contractBalance);
        }

        userLastOperationTime[msg.sender] = now;
    }

    function() external payable {
        if (msg.value >= INVEST_MIN_AMOUNT) {
            addInvest();
        } else {
            payDividends();

            // update last withdraw timestamp for user
            userLastWithdrawTime[msg.sender] = now;
        }
    }

    function bytesToAddress(bytes data) private pure returns (address addr) {
        assembly {
            addr := mload(add(data, 20))
        }
    }
}

/**
* @title SafeMath
* @dev Math operations with safety checks that revert on error
*/
library SafeMath {

    /**
    * @dev Multiplies two numbers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0); // Solidity only automatically asserts when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
    * @dev Adds two numbers, reverts on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }
}

Distribution of funds

The smart contract "Contractum" is programmed in such a way that it is absolutely transparent in defining all incoming funds. Its work is fully automated, and no one, not even the administration, can change its algorithms.

  • 88% - goes to the general balance of a smart contract, from where they are spent exclusively on payments to participants

  • 7% - marketing expenses (for advertising and marketing support)

  • 5% - technical support and administration commission

Referral system

You will receive 5% of the deposits of your partners automatically to your wallet.
In order for the system to understand that the investor is your partner, he needs to specify the number of your ETH wallet in the additional field "Add Data" when making his deposit. Affiliate income will come to your address automatically.

How to make a deposit?

In order to make a deposit, send any amount greater than 0.01 ETH to the wallet of our smart contract: Copy address Check contract
ATTENTION!
We work only with personal ETH-wallets! We do not accept deposits through exchange services and exchanges!
In the case of a deposit with them your funds will be lost!

Recommended GAS limit for transactions:
200 000


Recommended wallets for investment:
MyEtherWallet.com MetaMask.io Jaxx.io TrustWalletApp.com

How to order a payment?

To order a payment, send 0 ETH (or any amount) to the wallet of our smart contract: Copy address Check contract
Your payment will automatically come to your wallet in the same transaction. It is necessary to order payment only from the same wallet address from which the deposit was made.

Project statistics

16

days online
launch date: 01.11.2018

122

total number of our participants

Sum of all deposits (ETH):

183.9379

Total paid to participants (ETH):

28.9339

Go to Personal Account

Still have questions?

Frequently Asked Questions

What is "Contractum" and how safe is it?
Contractum.cc is a project based on a smart contract with a function of repudiation of property. This means that the administration of the project cannot affect its work in any way, nor can it use funds for other purposes (as it does not have access to withdrawal of funds from the address of the contract). Thus, the work of the project is protected from the human factor. It is as safe as it can be.
How are incoming funds distributed?
The distribution system is absolutely transparent:
88% goes to participants via payments
(one of the highest rates in the industry)
7% on advertising and marketing
5% for technical support and administration commission
How much can you earn?
We offer one of the most favorable conditions among similar projects:
4% per day for lifetime (base rate)
+0.1% of daily income for each full day when you do not request payment (personal interest)
+0.1% to daily income for every 100 ETH on the balance of the smart contract at the time of the payment request
How to participate and make a profit?
To make a deposit, simply send any amount (more than 0.01 ETH) from your personal (not exchange!) wallet to the address of the smart contract. Profit is charged once a minute, that is, you can withdraw at least several times a day (just send 0 ETH to the contract address with the established Gas Limit 200000), but remember that you get an additional 0.1% of daily income for every full day when you not order your payment.
Can I request a deposit back?
The deposit is included in the payments, that is, your breakeven will come in a maximum of 25 days (and if you correctly build the investment strategy, it is much faster due to the additional interest on your income (see above) and depending on the balance on the address of the smart contract).
Do you have an affiliate program?
Yes, you will receive 5% of the deposits of your partners automatically to your wallet. In order for the system to understand that the investor is your partner, he needs to specify the number of your ETH wallet in the additional Add Data field when making his deposit. Affiliate income will come to your address automatically.