Contract Name:
ThreeFMutual
Contract Source Code:
File 1 of 1 : ThreeFMutual
pragma solidity 0.5.16;
contract ThreeFMutual {
using SafeMath for *;
//*********
// STRUCTS
//*********
struct Player {
uint256 id; // agent id
bytes32 name; // agent name
uint256 ref; // referral vault
bool isAgent; // referral activated
bool claimed; // insurance claimed
uint256 eth; // eth player has paid
uint256 shares; // shares
uint256 units; // uints of insurance
uint256 plyrLastSeen; // last day player played
uint256 mask; // player mask
uint256 level; // agent level
uint256 accumulatedRef; // accumulated referral income
}
//***************
// EXTERNAL DATA
//***************
VAT vat = VAT(0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B);
Underwriter underwriter = Underwriter(0xE58cDe3CbEeCC8d9306f482729084B909Afa2357);
Agency agency = Agency(0x7Bc360ebD65eFa503FF189A0F81f61f85D310Ec3);
address payable constant private hakka = address(0x83D0D842e6DB3B020f384a2af11bD14787BEC8E7);
address payable constant private IIP = address(0x9933AD4D38702cdC28C5DB2F421F1F02CF530780);
uint256 public end;
bool public ended;
//******************
// GLOBAL VARIABLES
//******************
mapping(address => mapping(uint256 => uint256)) public unitToExpirePlayer;
mapping(uint256 => uint256) public unitToExpire; // unit of insurance due at day x
uint256 public issuedInsurance; // all issued insurance
uint256 public ethOfShare; // virtual eth pointer
uint256 public shares; // total share
uint256 public pool; // eth gonna pay to beneficiary
uint256 public today; // today's date
uint256 public _now; // current time
uint256 public mask; // global mask
uint256 public agents; // number of agent
// player data
mapping(address => Player) public player; // player data
mapping(uint256 => address) public agentxID_; // return agent address by id
mapping(bytes32 => address) public agentxName_; // return agent address by name
// constant parameters
uint256 constant maxInsurePeriod = 100;
uint256 constant maxLevel = 10;
// rate of buying x day insurance
uint256[101] public rate =
[0,
1000000000000000000,
1990000000000000000,
2970100000000000000,
3940399000000000000,
4900995010000000000,
5851985059900000000,
6793465209301000000,
7725530557207990000,
8648275251635910100,
9561792499119550999,
10466174574128355489,
11361512828387071934,
12247897700103201215,
13125418723102169203,
13994164535871147511,
14854222890512436036,
15705680661607311676,
16548623854991238559,
17383137616441326173,
18209306240276912911,
19027213177874143782,
19836941046095402344,
20638571635634448321,
21432185919278103838,
22217864060085322800,
22995685419484469572,
23765728565289624876,
24528071279636728627,
25282790566840361341,
26029962661171957728,
26769663034560238151,
27501966404214635769,
28226946740172489411,
28944677272770764517,
29655230500043056872,
30358678195042626303,
31055091413092200040,
31744540498961278040,
32427095093971665260,
33102824143031948607,
33771795901601629121,
34434077942585612830,
35089737163159756702,
35738839791528159135,
36381451393612877544,
37017636879676748769,
37647460510879981281,
38270985905771181468,
38888276046713469653,
39499393286246334956,
40104399353383871606,
40703355359850032890,
41296321806251532561,
41883358588189017235,
42464525002307127063,
43039879752284055792,
43609480954761215234,
44173386145213603082,
44731652283761467051,
45284335760923852380,
45831492403314613856,
46373177479281467717,
46909445704488653040,
47440351247443766510,
47965947734969328845,
48486288257619635557,
49001425375043439201,
49511411121293004809,
50016297010080074761,
50516134039979274013,
51010972699579481273,
51500862972583686460,
51985854342857849595,
52465995799429271099,
52941335841434978388,
53411922483020628604,
53877803258190422318,
54339025225608518095,
54795634973352432914,
55247678623618908585,
55695201837382719499,
56138249819008892304,
56576867320818803381,
57011098647610615347,
57440987661134509194,
57866577784523164102,
58287912006677932461,
58705032886611153136,
59117982557745041605,
59526802732167591189,
59931534704845915277,
60332219357797456124,
60728897164219481563,
61121608192577286747,
61510392110651513880,
61895288189544998741,
62276335307649548754,
62653571954573053266,
63027036235027322733,
63396765872677049506];
// threshold of agent upgrade
uint256[10] public requirement =
[0,
73890560989306501,
200855369231876674,
545981500331442382,
1484131591025766010,
4034287934927351160,
10966331584284585813,
29809579870417282259,
81030839275753838749,
220264657948067161559];
//******************
// EVENT
//******************
event UPGRADE (address indexed agent, uint256 indexed level);
event BUYINSURANCE(address indexed buyer, uint256 indexed start, uint256 unit, uint256 date);
//******************
// MODIFIER
//******************
modifier isHuman() {
require(msg.sender == tx.origin, "sorry humans only");
_;
}
//******************
// CORE FUNCTIONS
//******************
/**
* @dev Constructor
* @notice Initialize the time
*/
constructor() public {
_now = now;
today = _now / 1 days;
}
/**
* @dev Ticker
* @notice It is called everytime when a player interacts with this contract
* @return true if MakerDAO has been shut down, false otherwise
*/
function tick()
internal
returns(bool)
{
if(!ended) {
if (_now != now) {
_now = now;
uint256 _today = _now / 1 days; // the current day as soon as ticker is called
//check MakerDAO status
if(vat.live() == 0) {
ended = true;
end = now;
}
// calculate the outdated issuedInsurance
while (today < _today) {
issuedInsurance = issuedInsurance.sub(unitToExpire[today]);
unitToExpire[today] = 0;
today += 1;
}
}
}
return ended;
}
/**
* @dev Register
* @notice Register a name by a human player
*/
function register(string calldata _nameString)
external
payable
isHuman()
{
bytes32 _name = agency.register(_nameString);
address _agent = msg.sender;
require(msg.value >= 10000000000000000, "insufficient amount");
require(agentxName_[_name] == address(0), "name registered");
if(!player[_agent].isAgent){
agents += 1;
player[_agent].isAgent = true;
player[_agent].id = agents;
player[_agent].level = 1;
agentxID_[agents] = _agent;
emit UPGRADE(_agent,player[_agent].level);
}
// set name active for the player
player[_agent].name = _name;
agentxName_[_name] = _agent;
sendContract(hakka, msg.value);
}
/**
* @dev Upgrade
* @notice Upgrade when a player's referral bonus meet the requirement
*/
function upgrade()
external
isHuman()
{
address _agent = msg.sender;
require(player[_agent].isAgent);
require(player[_agent].level < maxLevel);
if(player[_agent].accumulatedRef >= requirement[player[_agent].level]) {
player[_agent].level = (1).add(player[_agent].level);
emit UPGRADE(_agent,player[_agent].level);
}
}
//using address for referral
function buy(address payable _agent, uint256 _date)
isHuman()
public
payable
{
// ticker
if(tick()){
sendHuman(msg.sender, msg.value);
return;
}
// validate agent
if(!player[_agent].isAgent){
_agent = address(0);
}
buyCore(msg.sender, msg.value, _date, _agent);
}
//using ID for referral
function buy(uint256 _agentId, uint256 _date)
isHuman()
public
payable
{
// ticker
if(tick()){
sendHuman(msg.sender, msg.value);
return;
}
//query agent
address payable _agent = address(uint160(agentxID_[_agentId]));
buyCore(msg.sender, msg.value, _date, _agent);
}
//using name for referral
function buy(bytes32 _agentName, uint256 _date)
isHuman()
public
payable
{
// ticker
if(tick()){
sendHuman(msg.sender, msg.value);
return;
}
//query agent
address payable _agent = address(uint160(agentxName_[_agentName]));
buyCore(msg.sender, msg.value, _date, _agent);
}
// contract wallets, sorry insurance only for human
function buy()
public
payable
{
// ticker
if(tick()) {
if(msg.sender == tx.origin)
sendHuman(msg.sender, msg.value);
else
sendContract(msg.sender, msg.value);
return;
}
buyCore(msg.sender, msg.value, 0, address(0));
}
// fallback
function () external payable {
buy();
}
/**
* @dev Core part of buying
*/
function buyCore(address _buyer, uint256 _eth, uint256 _date, address payable _agent) internal {
updatePlayerUnit(_buyer);
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 10000000000000000000000, "no vitalik, no");
if(_date > maxInsurePeriod){
_date = maxInsurePeriod;
}
uint256 _rate = rate[_date] + 1000000000000000000;
uint256 ethToBuyShare = _eth.mul(1000000000000000000) / _rate;
//-- ethToBuyShare is a virtual amount used to represent the eth player paid for buying shares
//which is usually different from _eth
// get value of shares and insurances can be bought
uint256 _share = underwriter.mintShare(ethOfShare, ethToBuyShare);
uint256 _unit = (_date == 0)? 0: _share;
uint256 newDate = today + _date - 1;
// update global data
ethOfShare = ethOfShare.add(ethToBuyShare);
shares = shares.add(_share);
unitToExpire[newDate] = unitToExpire[newDate].add(_unit);
issuedInsurance = issuedInsurance.add(_unit);
// update player data
player[_buyer].eth = player[_buyer].eth.add(_eth);
player[_buyer].shares = player[_buyer].shares.add(_share);
player[_buyer].units = player[_buyer].units.add(_unit);
unitToExpirePlayer[_buyer][newDate] = unitToExpirePlayer[_buyer][newDate].add(_unit);
distributeEx(_eth, _agent);
distributeIn(_buyer, _eth, _share);
emit BUYINSURANCE(_buyer, today, _unit, _date);
emit Transfer(address(0), _buyer, _share);
}
/**
* @dev Update player's units of insurance
*/
function updatePlayerUnit(address _player) internal {
uint256 _today = player[_player].plyrLastSeen;
uint256 expiredUnit = 0;
if(_today != 0){
while(_today < today){
expiredUnit = expiredUnit.add(unitToExpirePlayer[_player][_today]);
unitToExpirePlayer[_player][_today] = 0;
_today += 1;
}
player[_player].units = player[_player].units.sub(expiredUnit);
}
player[_player].plyrLastSeen = today;
}
/**
* @dev pay external stakeholder
*/
function distributeEx(uint256 _eth, address payable _agent) internal {
// 20% to external
uint256 ex = _eth / 5 ;
// 10% to IIP
uint256 _iip = _eth / 10;
if(player[_agent].isAgent){
uint256 refRate = player[_agent].level.add(6);
uint256 _ref = _eth.mul(refRate) / 100;
player[_agent].ref = player[_agent].ref.add(_ref);
player[_agent].accumulatedRef = player[_agent].accumulatedRef.add(_ref);
ex = ex.sub(_ref);
}
sendContract(IIP, _iip);
sendContract(hakka, ex);
}
/**
* @dev Distribute to internal
*/
function distributeIn(address _buyer, uint256 _eth, uint256 _shares) internal {
// 15% to share holder
uint256 _div = _eth.mul(3) / 20;
// 55% to insurance pool
uint256 _pool = _eth.mul(55) / 100;
// distribute dividend share and collect dust
uint256 _dust = updateMasks(_buyer, _div, _shares);
// add eth to pool
pool = pool.add(_dust).add(_pool);
}
function updateMasks(address _player, uint256 _div, uint256 _shares)
private
returns(uint256)
{
// calculate profit per share & global mask based on this buy: (dust goes to pool)
uint256 _ppt = _div.mul(1000000000000000000) / shares;
mask = mask.add(_ppt);
// calculate player earning from their own buy (only based on the shares
// they just bought). & update player earnings mask
uint256 _pearn = (_ppt.mul(_shares)) / 1000000000000000000;
player[_player].mask = (((mask.mul(_shares)) / 1000000000000000000).sub(_pearn)).add(player[_player].mask);
// calculate & return dust
return(_div.sub( _ppt.mul(shares) / 1000000000000000000));
}
/**
* @dev Submit a claim from a beneficiary
*/
function claim()
isHuman()
public
{
require(tick(), "not yet"); // MakerDAO shutdown!
address payable beneficiary = msg.sender;
require(!player[beneficiary].claimed, "already claimed");
updatePlayerUnit(beneficiary);
uint256 amount = pool.mul(player[beneficiary].units) / issuedInsurance;
player[beneficiary].claimed = true;
sendHuman(beneficiary, amount);
}
/**
* @dev Withdraw dividends and ref
*/
function withdraw()
public
{
// get player earnings
uint256 _eth;
_eth = withdrawEarnings(msg.sender);
// pay
if (_eth > 0) {
if(msg.sender == tx.origin)
sendHuman(msg.sender, _eth);
else
sendContract(msg.sender, _eth);
}
}
function withdrawEarnings(address _player)
private
returns(uint256)
{
uint256 _div = calcUnMaskedEarnings(_player); //dividend
uint256 _ref = player[_player].ref; // referral
uint256 _earnings = _div.add(_ref);
if (_earnings > 0) {
player[_player].ref = 0;
player[_player].mask = _div.add(player[_player].mask);
}
return(_earnings);
}
function calcUnMaskedEarnings(address _player)
private
view
returns(uint256)
{
return (mask.mul(player[_player].shares) / 1000000000000000000).sub(player[_player].mask);
}
//******************
// GETTERS
//******************
/**
* @dev Return the price buyer will pay for next 1 individual share.
* @return Price for next share bought (in wei format)
*/
function getBuyPrice() external view returns(uint256) {
return underwriter.burnShare(shares.add(1000000000000000000), 1000000000000000000);
}
/**
* @dev Get the units of insurance of player
* @return Amount of existing units of insurance
*/
function getCurrentUnit(address _player)
external
view
returns(uint256)
{
uint256 _unit = player[_player].units;
uint256 _today = player[_player].plyrLastSeen;
uint256 expiredUnit = 0;
if(_today != 0) {
while(_today < today){
expiredUnit = expiredUnit.add(unitToExpirePlayer[_player][_today]);
_today += 1;
}
}
return _unit == 0 ? 0 : _unit.sub(expiredUnit);
}
/**
* @dev Get the list of units of insurace going to expire of a player
* @return List of units of insurance going to expire from a player
*/
function getExpiringUnitListPlayer(address _player)
external
view
returns(uint256[maxInsurePeriod] memory expiringUnitList)
{
for(uint256 i=0; i<maxInsurePeriod; i++) {
expiringUnitList[i] = unitToExpirePlayer[_player][today+i];
}
return expiringUnitList;
}
/**
* @dev Get the list of units of insurace going to expire
* @return List of units of insurance going to expire
*/
function getExpiringUnitList()
external
view
returns(uint256[maxInsurePeriod] memory expiringUnitList)
{
for(uint256 i=0; i<maxInsurePeriod; i++){
expiringUnitList[i] = unitToExpire[today+i];
}
return expiringUnitList;
}
//******************
// ERC20
//******************
string public constant name = "Third Floor Mutual";
string public constant symbol = "3FM";
uint8 public constant decimals = 18;
function totalSupply() external view returns(uint256) {
if(ended) return 0;
return shares;
}
function balanceOf(address who) external view returns(uint256) {
if(ended) return 0;
return player[who].shares;
}
event Transfer(address indexed from, address indexed to, uint256 amount);
//******************
// send eth
//******************
function sendHuman(address to, uint256 amount) internal returns(bool success) {
address payable recipient = address(uint160(to));
(success, ) = recipient.call.value(amount)("");
}
function sendContract(address to, uint256 amount) internal returns(bool success) {
address payable recipient = address(uint160(to));
(new SafeSend).value(amount)(recipient);
return true;
}
}
contract VAT {
function live() external returns(uint256);
}
contract SafeSend {
constructor(address payable to) public payable {
selfdestruct(to);
}
}
contract Underwriter {
function mintShare(uint256 _curEth, uint256 _newEth) external pure returns (uint256);
function burnShare(uint256 _curShares, uint256 _sellShares) external pure returns (uint256);
function shares(uint256 _eth) public pure returns(uint256);
function eth(uint256 _shares) public pure returns(uint256);
}
contract Agency {
function register(string memory _input) public pure returns(bytes32);
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) return 0;
c = a * b;
require(c / a == b);
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
require(b <= a);
c = a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a);
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = add(x >> 1, 1);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z), z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y) internal pure returns(uint256 z) {
z = 1;
while(y != 0){
if(y % 2 == 1)
z = mul(z,x);
x = sq(x);
y = y / 2;
}
return z;
}
}