| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 | + + + + + + + + + + + + + + +4× + + + + + + + + + + +3× +2× +2× +2× + + + + + + + + +2× +2× +2× +2× + + + + + + + +3× +2× + + + + +5× +4× + + + + +13× +10× + + + + +5× +4× + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+// @title A contract for granting and revoking access levels to different users
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice Made for platforms that require hierarchical access restrictions
+contract AccessHierarchy {
+
+ Database public database;
+ uint8 public upperAccessLevel;
+
+ // @notice Constructor: Inititalize Database
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice Owner can manually grant access to a user here. WIll be used for KYC approval
+ // @param Address of new user.
+ // @param The level of access granted by owner/burningcontract
+ function approveUser(address _newUser, uint _accessLevel)
+ onlyPlatform
+ noEmptyAddress(_newUser)
+ public
+ returns (bool) {
+ require(_accessLevel < upperAccessLevel && _accessLevel != uint8(0));
+ database.setUint(keccak256(abi.encodePacked("userAccess", _newUser)), _accessLevel);
+ emit LogUserApproved(_newUser, _accessLevel);
+ return true;
+ }
+
+ // @notice Owner can remove access for users
+ // @param User to be removed
+ function removeUser(address _user)
+ onlyOwner
+ public
+ returns (bool) {
+ uint accessLevel = database.uintStorage(keccak256(abi.encodePacked("userAccess", _user)));
+ database.deleteUint(keccak256(abi.encodePacked("userAccess", _user)));
+ emit LogUserRemoved(_user, accessLevel);
+ return true;
+ }
+
+ // @notice Owner can set the upper bound on access levels
+ // @param (uint8) _newUpperLimit = The highest access level on the platform
+ function setUpperAccessLevel(uint8 _newUpperLimit)
+ public
+ onlyOwner {
+ require(_newUpperLimit > uint8(0));
+ upperAccessLevel = _newUpperLimit;
+ }
+
+ // @notice Deny empty address parameters
+ modifier noEmptyAddress(address _param) {
+ require(_param != address(0));
+ _;
+ }
+
+ // @notice Deny all callers except owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice only contracts on the platform can call.
+ modifier onlyPlatform {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+ event LogUserApproved(address _user, uint _approvalLevel);
+ event LogUserRemoved(address indexed _user, uint indexed _accessLevel);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 | + + + + + + + + + + + + + + + + + + +6× +6× +6× + + + + + + + + + + +40× +39× +39× + + + + + + + + + + + +15× +15× +15× + + + + + + + +1× + + + + + + + + +15× +15× + + + + +45× +43× + + + + +43× +43× +40× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../interfaces/BurnableERC20.sol';
+import "../interfaces/DBInterface.sol";
+
+/// @title A contract for burning ERC20 tokens as usage fee for dapps
+/// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+/// @notice Allows Dapps to call this contract to burn ERC20 tokens as a usage fee
+/// @dev This contract does not accept tokens. It only burns tokens from investors wallets to run platform functionality
+contract ERC20Burner {
+
+ BurnableERC20 public token; // The instance of the ERC20 burner contract
+ DBInterface public database; // The datbase instance
+
+
+ // @notice constructor: initializes database and the MYB token
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ token = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ Erequire(address(token) != address(0));
+ }
+
+ // @notice authorized contracts can burn mybit tokens here if the investor has approved this contract to do so
+ // @param (address) _tokenHolder = the address of the mybit token holder who wishes to burn _amount of tokens
+ // @param (uint) _amount = the amount of tokens to be burnt (must include decimal places)
+ function burn(address _tokenHolder, uint _amount)
+ external
+ onlyPlatformContracts(msg.sender)
+ acceptedState(_tokenHolder)
+ returns (bool) {
+ require(token.burnFrom(_tokenHolder, _amount));
+ emit LogMYBBurned(_tokenHolder, msg.sender, _amount);
+ return true;
+ }
+
+ // @notice owners can set the cost of functionality on the platform here.
+ // @dev _amount will be how many platformTokens are burned to call the method at _contractAddress
+ // @param (bytes4) _methodID: the methodID of the function which is to require a burning fee
+ // @param (address) _contractAddress: the address of the contract where this method is contained
+ function setFee(bytes4 _methodID, address _contractAddress, uint _amount)
+ external
+ onlyOwner
+ returns (bool) {
+ //Sets the price to burn per function in MyB.
+ database.setUint(keccak256(abi.encodePacked(_methodID, _contractAddress)), _amount);
+ emit LogFeeAdded(_contractAddress, _methodID, _amount);
+ return true;
+ }
+
+
+ // @notice fallback function. Rejects all ether
+ function ()
+ external
+ payable {
+ revert();
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice reverts if msg.sender isn't the owner
+ modifier onlyOwner {
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice reverts if address isn't authorized to burn MYB
+ modifier onlyPlatformContracts(address _burner) {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", _burner))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't accepted current contract state or if he doesn't ignore state changes entirely
+ modifier acceptedState(address _investor) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ require(database.boolStorage(keccak256(abi.encodePacked(currentState, _investor))) || database.boolStorage(keccak256(abi.encodePacked("ignoreStateChanges", _investor))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogMYBBurned(address _tokenHolder, address _burningContract, uint _amount);
+ event LogFeeAdded(address indexed _contractAddress, bytes4 _methodID, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + +1× +1× +1× + + + + + + + + +1× +1× +1× + + + + + + | pragma solidity 0.4.24;
+
+
+import '../math/SafeMath.sol';
+import './AccessHierarchy.sol';
+
+// @title A contract extension that gives an expiration date to user access
+// @author Kyle Dewhurst, MyBit Foundation
+contract Expirable is AccessHierarchy {
+ using SafeMath for uint;
+
+ uint public expirationLength = uint256(31557600); // 365 days
+
+ constructor(address _database) public AccessHierarchy(_database){}
+
+ //------------------------------------------------------------------------------------------------------------------
+ // @notice Owner can manually grant access to a user here. WIll be used for KYC approval
+ // @param Address of new user.
+ // @param The level of access granted by owner/burningcontract
+ // TODO: does the modifier in AccessHierarchy throw?
+ //------------------------------------------------------------------------------------------------------------------
+ function approveTemporaryUser(address _newUser, uint _accessLevel)
+ onlyOwner
+ noEmptyAddress(_newUser)
+ public
+ returns (bool) {
+ Erequire(approveUser(_newUser, _accessLevel));
+ uint expiry = now.add(expiry);
+ database.setUint(keccak256(abi.encodePacked("userAccessExpiration", _newUser)), expiry);
+ return true;
+ }
+
+
+ // @notice Owner can remove access for users
+ // @param User to be removed
+ function removeTemporaryUser(address _user)
+ onlyOwner
+ public
+ returns (bool) {
+ Erequire(removeUser(_user));
+ database.deleteUint(keccak256(abi.encodePacked("userAccessExpiration", _user)));
+ return true;
+ }
+
+
+ // @notice Owner can change the length of expiration here
+ // @param (uint) _newExpirationLength = The number of seconds until the access expires
+ function changeExpirationLength(uint _newExpirationLength)
+ external
+ onlyOwner {
+ uint oldExpiration = expirationLength;
+ expirationLength = _newExpirationLength;
+ emit LogExpirationLengthChanged(oldExpiration, expirationLength);
+ }
+
+ event LogExpirationLengthChanged(uint _oldExpirationLength, uint _newExpirationLength);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | + + + + + + + + + + + + + + + +1× +1× + + + + + + +1× + + + + + + | pragma solidity 0.4.24;
+
+import './AccessHierarchy.sol';
+
+// @title A contract that manages KYC approval
+// @notice KYC can be granted or revoked here
+// @author Kyle Dewhurst, MyBit Foundation
+
+contract KYC is AccessHierarchy {
+
+ constructor(address _database) public AccessHierarchy(_database){}
+
+ // @notice Owner can approve KYC for user
+ function approveKYC(address _user)
+ onlyOwner
+ external {
+ database.setBool(keccak256(abi.encodePacked("kycApproved", _user)), true);
+ emit LogKYCApproved(msg.sender, _user);
+ }
+
+ // @notice Owner can approve KYC for user
+ function revokeKYC(address _user)
+ onlyOwner
+ external {
+ database.deleteBool(keccak256(abi.encodePacked("kycApproved", _user)));
+ }
+
+
+ event LogKYCApproved(address _owner, address _user);
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AccessHierarchy.sol | +100% | +12/12 | +100% | +10/10 | +100% | +7/7 | +100% | +17/17 | +|
| ERC20Burner.sol | +100% | +13/13 | +80% | +8/10 | +100% | +7/7 | +100% | +17/17 | +|
| Expirable.sol | +100% | +8/8 | +50% | +2/4 | +100% | +4/4 | +100% | +10/10 | +|
| KYC.sol | +100% | +1/1 | +100% | +0/0 | +100% | +3/3 | +100% | +3/3 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + +5× +5× +5× +5× +5× +3× +3× +3× +3× +3× +3× + + +2× +2× + +4× +4× + + + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + +3× +3× +3× +3× +2× +2× +2× +2× +2× +2× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +3× +3× +3× +3× + + + + + + + + + + + + + + +9× +8× + + + + +5× +5× + + + + +9× +9× + + + + +7× +6× + + + + +2× +1× + + + + +7× +6× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../interfaces/ERC20DividendInterface.sol";
+import "../access/ERC20Burner.sol";
+
+// @title An asset crowdsale contract which accepts funding from ERC20 tokens.
+// @notice Begins a crowdfunding period for a digital asset, minting asset dividend tokens to investors when particular ERC20 token is received
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice creates a dividend token to represent the newly created asset.
+contract CrowdsaleERC20{
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ // @notice Constructor: initializes database instance
+ // @param: The address for the platform database
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+
+ // @notice Investors can send ERC20 tokens here to fund an asset, receiving an equivalent number of asset-tokens.
+ // @dev investor must approve this contract to transfer tokens
+ // @param (bytes32) _assetID = The ID of the asset tokens, investor wishes to purchase
+ // @param (uint) _amount = The amount to spend purchasing this asset
+ function buyAssetOrderERC20(bytes32 _assetID, uint _amount)
+ external
+ validAsset(_assetID)
+ beforeDeadline(_assetID)
+ notFinalized(_assetID)
+ burnRequired
+ returns (bool) {
+ ERC20DividendInterface assetToken = ERC20DividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ uint amountToRaise = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ uint tokensRemaining = amountToRaise.sub(assetToken.totalSupply());
+ if (_amount >= tokensRemaining) {
+ Erequire(fundingToken.transferFrom(msg.sender, address(this), tokensRemaining)); // transfer investors tokens into contract
+ Erequire(assetToken.mint(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))), database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID))) ));
+ Erequire(finalizeCrowdsale(_assetID));
+ Erequire(assetToken.mint(msg.sender, tokensRemaining)); // Send remaining asset tokens to investor
+ Erequire(assetToken.finishMinting());
+ require(payoutERC20(_assetID, amountToRaise)); // 1 token = 1 wei
+ }
+ else {
+ Erequire(fundingToken.transferFrom(msg.sender, address(this), _amount));
+ Erequire(assetToken.mint(msg.sender, _amount));
+ }
+ emit LogAssetPurchased(_assetID, msg.sender, _amount); //Should amount listed be how much they spent or how much they received?
+ return true;
+ }
+
+
+ // @notice Contributors can retrieve their funds here if crowdsale has paased deadline
+ // @param (bytes32) _assetID = The ID of the asset which didn't reach it's crowdfunding goals
+ function refund(bytes32 _assetID)
+ external
+ whenNotPaused
+ validAsset(_assetID)
+ afterDeadline(_assetID)
+ notFinalized(_assetID)
+ returns (bool) {
+ Erequire(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) != 0);
+ database.deleteUint(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ ERC20DividendInterface assetToken = ERC20DividendInterface(tokenAddress);
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ uint refundValue = assetToken.totalSupply(); //token=wei
+ fundingToken.approve(tokenAddress, refundValue);
+ assetToken.issueDividends(refundValue);
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice This is called once funding has succeeded. Sends Ether to a distribution contract where operator/assetManager can withdraw
+ // @dev The contract manager needs to know the address PlatformDistribution contract
+ function payoutERC20(bytes32 _assetID, uint _amount)
+ private
+ whenNotPaused
+ returns (bool) {
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ address operator = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ address platformWallet = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ require(operator != address(0) && platformWallet != address(0));
+ uint operatorPortion = _amount.mul(99).div(100);
+ uint platformPortion = _amount.sub(operatorPortion);
+ fundingToken.transfer(platformWallet, platformPortion);
+ fundingToken.transfer(operator, operatorPortion);
+ emit LogAssetPayout(_assetID, operator, _amount);
+ return true;
+ }
+
+ // @notice platform owners can recover tokens here
+ function recoverTokens(address _erc20Token)
+ onlyOwner
+ external {
+ ERC20 thisToken = ERC20(_erc20Token);
+ uint contractBalance = thisToken.balanceOf(address(this));
+ thisToken.transfer(msg.sender, contractBalance);
+ }
+
+ // @notice platform owners can destroy contract here
+ function destroy()
+ onlyOwner
+ external {
+ emit LogDestruction(address(this).balance, msg.sender);
+ selfdestruct(msg.sender);
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice internal function for freeing up storage after crowdsale finishes
+ // @param the ID of this asset.
+ function finalizeCrowdsale(bytes32 _assetID)
+ internal
+ whenNotPaused
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)), true);
+ database.deleteUint(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerFee", _assetID)));
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice function won't run if owners have paused this contract
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't approved burner to burn platform token
+ modifier burnRequired {
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier beforeDeadline(bytes32 _assetID) {
+ require(now <= database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier afterDeadline(bytes32 _assetID) {
+ require(now > database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice returns true if crowdsale is not finshed
+ modifier notFinalized(bytes32 _assetID) {
+ require( !database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))) );
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogAssetPurchased(bytes32 indexed _assetID, address indexed _sender, uint _amount);
+ event LogAssetPayout(bytes32 indexed _assetID, address indexed _operator, uint _amount);
+ event LogDestruction(uint _amountSent, address indexed _caller);
+ event LogAssetInfo(uint _investorAmount, uint _tokensRemaining);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + +5× +5× +5× +5× + +3× +3× +3× +3× +3× +3× + + +2× + +5× +5× + + + + + + + + + + + + +2× +2× +2× +2× +2× +2× +2× + + + + + + + + + + + + + + + +1× +1× + + + + + + +1× + + + + + + + + + + + + + +3× +3× +3× +3× +3× +3× +3× +3× +3× + + + + + + + +3× +3× +3× +3× + + + + + + + + + + +8× +8× + + + + +2× +1× + + + + +5× +5× + + + + +3× +2× + + + + +10× +10× + + + + +8× +5× + + + + +2× +2× + + + + +7× +7× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../interfaces/EtherDividendInterface.sol";
+import "../access/ERC20Burner.sol";
+
+// @title An asset crowdsale contract, which accepts Ether for funding.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @notice Starts a new crowdsale and returns asset dividend tokens for Wei received.
+// @dev The AssetManager
+contract CrowdsaleETH {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ // @notice Constructor: Initiates the database
+ // @param: The address for the database contract
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+
+ // @notice Investors can send Ether here to fund asset, receiving an equivalent number of asset-tokens.
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ function buyAssetOrderETH(bytes32 _assetID)
+ external
+ payable
+ requiresEther
+ validAsset(_assetID)
+ beforeDeadline(_assetID)
+ notFinalized(_assetID)
+ burnRequired
+ returns (bool) {
+ EtherDividendInterface assetToken = EtherDividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint amountToRaise = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ uint tokensRemaining = amountToRaise.sub(assetToken.totalSupply());
+ if (msg.value >= tokensRemaining) {
+ // Give assetManager his portion of tokens
+ Erequire(assetToken.mint(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))), database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID)))));
+ Erequire(finalizeCrowdsale(_assetID)); // delete unnecessary variables
+ Erequire(assetToken.mint(msg.sender, tokensRemaining)); // Send remaining asset tokens
+ Erequire(assetToken.finishMinting());
+ Erequire(payoutETH(_assetID, amountToRaise)); // 1 token = 1 wei
+ msg.sender.transfer(msg.value.sub(tokensRemaining)); // Return leftover WEI after cost of tokens calculated and subtracted from msg.value
+ }
+ else {
+ Erequire(assetToken.mint(msg.sender, msg.value));
+ }
+ emit LogAssetPurchased(_assetID, msg.sender, msg.value);
+ return true;
+ }
+
+
+ // @notice Contributors can retrieve their funds here if crowdsale has paased deadline and not reached its goal
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ function refund(bytes32 _assetID)
+ external
+ whenNotPaused
+ validAsset(_assetID)
+ afterDeadline(_assetID)
+ notFinalized(_assetID)
+ returns (bool) {
+ Erequire(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) != 0);
+ database.deleteUint(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("investorSupply", _assetID)));
+ EtherDividendInterface assetToken = EtherDividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint refundValue = assetToken.totalSupply(); //token=wei
+ assetToken.issueDividends.value(refundValue)();
+ return true;
+ }
+
+ // @notice platform owners can recover tokens here
+ function recoverTokens(address _erc20Token)
+ onlyOwner
+ external {
+ ERC20 thisToken = ERC20(_erc20Token);
+ uint contractBalance = thisToken.balanceOf(address(this));
+ thisToken.transfer(msg.sender, contractBalance);
+ }
+
+ // @notice platform owners can destroy contract here
+ function destroy()
+ onlyOwner
+ external {
+ emit LogDestruction(address(this).balance, msg.sender);
+ selfdestruct(msg.sender);
+ }
+
+ // @notice fallback function: reject ether
+ function ()
+ public
+ payable {
+ revert();
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice This is called once funding has succeeded. Sends Ether to a distribution contract where operator & assetManager can withdraw
+ // @dev The contract manager needs to know the address PlatformDistribution contract
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ // @param (uint) _amount = The amount of WEI to be sent to the platform + the operator
+ function payoutETH(bytes32 _assetID, uint _amount)
+ internal
+ returns (bool) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ address platformWallet = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ Erequire(operatorAddress != address(0) && platformWallet != address(0));
+ uint operatorPortion = _amount.mul(99).div(100);
+ uint platformPortion = _amount.sub(operatorPortion);
+ platformWallet.transfer(platformPortion);
+ operatorAddress.transfer(operatorPortion);
+ emit LogAssetPayout(_assetID, operatorAddress, _amount);
+ return true;
+ }
+
+ // @notice internal function for freeing up storage after crowdsale finishes
+ // @param the ID of this asset.
+ function finalizeCrowdsale(bytes32 _assetID)
+ internal
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)), true);
+ database.deleteUint(keccak256(abi.encodePacked("amountToRaise", _assetID))); // This is now represented as totalSupply in the asset-token
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerFee", _assetID))); // This is now represented as tokens in AssetManagerFunds.sol
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice Requires that Ether is sent with the transaction
+ modifier requiresEther() {
+ Erequire(msg.value > 0);
+ _;
+ }
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't approved burner to burn platform token
+ modifier burnRequired {
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ // @notice function won't run if owners have paused this contract
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier beforeDeadline(bytes32 _assetID) {
+ require(now <= database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier afterDeadline(bytes32 _assetID) {
+ Erequire(now > database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice returns true if crowdsale is not finshed
+ modifier notFinalized(bytes32 _assetID) {
+ Erequire( !database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))) );
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogAssetPurchased(bytes32 indexed _assetID, address indexed _sender, uint _amount);
+ event LogRefund(bytes32 indexed _assetID, address indexed _funder, uint _amount);
+ event LogAssetPayout(bytes32 indexed _assetID, address indexed _distributionContract, uint _amount);
+ event LogDestruction(uint _amountSent, address indexed _caller);
+ }
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + +6× +5× +5× +5× +4× +4× +3× +3× +3× +3× +3× +3× +3× +3× +3× +3× +3× + + + + + + + + + + +6× +6× + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendTokenERC20.sol";
+
+// @title A crowdsale generator contract
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @notice AssetManagers can initiate a crowdsale that accepts ERC20 tokens as payment here
+contract CrowdsaleGeneratorERC20 {
+ using SafeMath for uint256;
+
+ DBInterface private database;
+ ERC20Burner private burner;
+
+ uint constant scalingFactor = 1e32;
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // @notice AssetManagers can initiate a crowdfund for a new asset here
+ // @dev the crowdsaleERC20 contract is granted rights to mint asset-tokens as it receives funding
+ // @param (string) _assetURI = The location where information about the asset can be found
+ // @param (bytes32) _operatorID = The ID of the operator who is to create and install this asset
+ // @param (uint) _fundingLength = The number of seconds this crowdsale is to go on for until it fails
+ // @param (uint) _amountToRaise = The amount of tokens required to raise for the crowdsale to be a success
+ // @param (uint) _assetManagerPerc = The percentage of the total revenue which is to go to the AssetManager if asset is a success
+ // @param (address) _fundingToken = The ERC20 token to be used to fund the crowdsale (Operator must accept this token as payment)
+ function createAssetOrderERC20(string _assetURI, bytes32 _operatorID, uint _fundingLength, uint _amountToRaise, uint _assetManagerPerc, address _fundingToken)
+ external
+ burnRequired {
+ require(_amountToRaise > 0);
+ Erequire(_assetManagerPerc < 100);
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("acceptsToken", _operatorID, _fundingToken))));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) != address(0));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", assetID))) == 0);
+ address assetAddress = address(new DividendTokenERC20(_assetURI, database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleERC20"))), _fundingToken));
+ database.setUint(keccak256(abi.encodePacked("fundingDeadline", assetID)), now.add(_fundingLength));
+ uint assetManagerFee = _amountToRaise.mul(uint(100).mul(scalingFactor).div(uint(100).sub(_assetManagerPerc)).sub(scalingFactor)).div(scalingFactor);
+ database.setUint(keccak256(abi.encodePacked("amountToRaise", assetID)), _amountToRaise);
+ database.setUint(keccak256(abi.encodePacked("assetManagerFee", assetID)), assetManagerFee);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), assetAddress);
+ database.setBytes32(keccak256(abi.encodePacked("assetTokenID", assetAddress)), assetID);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("operator", assetID)), database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))));
+ database.setAddress(keccak256(abi.encodePacked("fundingToken", assetID)), _fundingToken);
+ emit LogAssetFundingStarted(assetID, msg.sender, _assetURI, assetAddress);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice reverts if AssetManager hasn't approved burner to burn platform token
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogAssetFundingStarted(bytes32 indexed _assetID, address indexed _assetManager, string _assetURI, address indexed _tokenAddress);
+ event LogSig(bytes4 _sig);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + +9× +8× +7× +7× +6× +6× +5× +5× +5× +5× +5× +5× +5× +5× +5× +5× +5× + + + + + + + + + + +9× +9× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendToken.sol";
+
+// @title A crowdsale generator contract
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice AssetManagers can initiate a crowdsale that accepts Ether as payment here
+contract CrowdsaleGeneratorETH {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ uint constant scalingFactor = 1e32; // Used to avoid rounding errors
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // @notice AssetManagers can initiate a crowdfund for a new asset here
+ // @dev the crowdsaleETH contract is granted rights to mint asset-tokens as it receives funding
+ // @param (string) _assetURI = The location where information about the asset can be found
+ // @param (bytes32) _operatorID = The ID of the operator who is to create and install this asset
+ // @param (uint) _fundingLength = The number of seconds this crowdsale is to go on for until it fails
+ // @param (uint) _amountToRaise = The amount of WEI required to raise for the crowdsale to be a success
+ // @param (uint) _assetManagerPerc = The percentage of the total revenue which is to go to the AssetManager if asset is a success
+ function createAssetOrderETH(string _assetURI, bytes32 _operatorID, uint _fundingLength, uint _amountToRaise, uint _assetManagerPerc)
+ external
+ burnRequired
+ returns (bool) {
+ require(_amountToRaise > 0);
+ require(_assetManagerPerc < 100);
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("acceptsEther", _operatorID))));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) != address(0));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", assetID))) == 0);
+ address assetAddress = address(new DividendToken(_assetURI, database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleETH"))))); // Gives this contract all new asset tokens
+ database.setUint(keccak256(abi.encodePacked("fundingDeadline", assetID)), now.add(_fundingLength));
+ uint assetManagerFee = _amountToRaise.mul(uint(100).mul(scalingFactor).div(uint(100).sub(_assetManagerPerc)).sub(scalingFactor)).div(scalingFactor);
+ database.setUint(keccak256(abi.encodePacked("assetManagerFee", assetID)), assetManagerFee);
+ database.setUint(keccak256(abi.encodePacked("amountToRaise", assetID)), _amountToRaise);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), assetAddress);
+ database.setBytes32(keccak256(abi.encodePacked("assetTokenID", assetAddress)), assetID);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("operator", assetID)), database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))));
+ emit LogAssetFundingStarted(assetID, msg.sender, _assetURI, address(assetAddress));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ // @notice reverts if asset manager is unable to burn pp
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogAssetFundingStarted(bytes32 indexed _assetID, address indexed _assetManager, string _assetURI, address indexed _tokenAddress);
+ event LogSig(bytes4 _sig);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| CrowdsaleERC20.sol | +88.37% | +38/43 | +66.67% | +24/36 | +78.57% | +11/14 | +88.14% | +52/59 | +|
| CrowdsaleETH.sol | +94.87% | +37/39 | +61.76% | +21/34 | +93.75% | +15/16 | +94.74% | +54/57 | +|
| CrowdsaleGeneratorERC20.sol | +100% | +12/12 | +75% | +9/12 | +100% | +3/3 | +100% | +21/21 | +|
| CrowdsaleGeneratorETH.sol | +100% | +13/13 | +83.33% | +10/12 | +100% | +3/3 | +100% | +21/21 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +6× + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + + + + +1× + + + + + + +1× +1× + + + + + + +3× + + + + + + +1× + + + + + + +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + +4× +4× + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + +1× + + + + + + +1× +1× +1× + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+import "../math/SafeMath.sol";
+
+interface TokenView {
+ function totalSupply() external view returns (uint);
+ function balanceOf(address _investor) external view returns (uint);
+ function valuePerToken() external view returns (uint);
+ function scalingFactor() external view returns (uint);
+ function assetIncome() external view returns (uint);
+}
+
+interface DBView {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function stringStorage(bytes32 _key) external view returns (string);
+ function addressStorage(bytes32 _key) external view returns (address);
+ function bytesStorage(bytes32 _key) external view returns (bytes);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+ function boolStorage(bytes32 _key) external view returns (bool);
+ function intStorage(bytes32 _key) external view returns (bool);
+}
+
+// @title A contract that gets variables from the _database
+// @notice The API contract can only view the database. It has no write privileges
+contract API {
+ using SafeMath for uint256;
+
+ DBView private database;
+
+ constructor(address _database)
+ public {
+ database = DBView(_database);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Governance + Function ID's
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ // @notice returns the amount of tokens unlocked and free to spend for _ser
+ function getNumTokensAvailable(bytes32 _assetID, address _investor)
+ public
+ view
+ returns (uint) {
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)));
+ address assetToken = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ uint balance = TokenView(assetToken).balanceOf(_investor);
+ return balance.sub(amountLocked);
+ }
+
+ function getInvestorVotes(bytes32 _executionID, address _investor)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("investorVotes", _executionID, _investor)));
+ }
+
+ function getTotalVotes(bytes32 _executionID)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("voteTotal", _executionID)));
+ }
+
+ function getCurrentConsensus(bytes32 _executionID, address _assetToken)
+ public
+ view
+ returns (uint) {
+ uint totalVotes = getTotalVotes(_executionID);
+ return (totalVotes * 100) / TokenView(_assetToken).totalSupply();
+ }
+
+ function getAssetManagerParameterHash(bytes32 _assetID, address _oldAssetManager, address _newAssetManager, uint _amount, bool _burn)
+ public
+ pure
+ returns (bytes32){
+ return keccak256(abi.encodePacked(_assetID, _oldAssetManager, _newAssetManager, _amount, _burn));
+ }
+
+ function getExecutionID(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ }
+
+ function getMethodID(string _functionString)
+ public
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked(_functionString)));
+ }
+
+ function getAssetID(address _broker, string _assetURI, uint _amountToRaise, bytes32 _operatorID)
+ public
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_broker, _amountToRaise, _operatorID, _assetURI));
+ }
+
+ function getOrderID(bytes _assetID, address _investor, uint _amount, uint _price, bool _buyOrder)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_assetID, _investor, _amount, _price, _buyOrder));
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Crowdsale and Assets
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ function generateAssetID(address _broker, uint _amountToRaise, bytes32 _operatorID, string _assetURI)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 assetID = keccak256(abi.encodePacked(_broker, _amountToRaise, _operatorID, _assetURI));
+ return assetID;
+ }
+
+ function getAssetID(address _tokenAddress)
+ public
+ view
+ returns(bytes32) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", _tokenAddress)));
+ return assetID;
+ }
+
+ function getAssetAddress(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address assetAddress = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ return assetAddress;
+ }
+
+ function getAssetFundingToken(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address fundingTokenAddress = database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID)));
+ return fundingTokenAddress;
+ }
+
+ // IF we decide not to store assetIncome
+ // function getAssetIncome(bytes32 _assetID)
+ // public
+ // view
+ // returns (uint) {
+ // TokenView asset = TokenView(getAssetAddress(_assetID));
+ // uint valuePerToken = asset.valuePerToken();
+ // return (valuePerToken * (asset.totalSupply())) / asset.scalingFactor();
+ // }
+
+ function getAssetROI(bytes32 _assetID)
+ public
+ view
+ returns (uint) {
+ TokenView assetToken = TokenView(getAssetAddress(_assetID));
+ return (assetToken.assetIncome() * 100) / assetToken.totalSupply();
+ }
+
+ function getAssetFundingGoal(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint fundingGoal = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ return fundingGoal;
+ }
+
+ function getAssetFundingDeadline(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint fundingDeadline = database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ return fundingDeadline;
+ }
+
+ function crowdsaleFinalized(bytes32 _assetID)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)));
+ return status;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Asset Manager and Operator
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function getAssetManager(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address managerAddress = database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID)));
+ return managerAddress;
+ }
+
+ function getAssetManagerFee(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint managerFee = database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID)));
+ return managerFee;
+ }
+
+ function getAssetManagerEscrowID(bytes32 _assetID, address _manager)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 managerEscrowID = keccak256(abi.encodePacked(_assetID, _manager));
+ return managerEscrowID;
+ }
+
+ function getAssetManagerEscrow(bytes32 _managerEscrowID)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", _managerEscrowID)));
+ }
+
+ function getAssetManagerEscrowRemaining(bytes32 _managerEscrowID)
+ public
+ view
+ returns(uint) {
+ uint redeemed = getAssetManagerEscrowRedeemed(_managerEscrowID);
+ uint brokerEscrow = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", _managerEscrowID))).sub(redeemed);
+ return brokerEscrow;
+ }
+
+ function getAssetManagerEscrowRedeemed(bytes32 _managerEscrowID)
+ public
+ view
+ returns(uint) {
+ uint escrowRedeemed = database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", _managerEscrowID)));
+ return escrowRedeemed;
+ }
+
+ function getAssetOperator(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ return operatorAddress;
+ }
+
+ function generateOperatorID(string _operatorURI)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 operatorID = keccak256(abi.encodePacked(_operatorURI));
+ return operatorID;
+ }
+
+ function getOperatorID(address _operatorAddress)
+ public
+ view
+ returns(bytes32) {
+ bytes32 operatorID = database.bytes32Storage(keccak256(abi.encodePacked("operator", _operatorAddress)));
+ return operatorID;
+ }
+
+ function getOperatorAddress(bytes32 _operatorID)
+ public
+ view
+ returns(address) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
+ return operatorAddress;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Stakeholders
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function generateOrderID(bytes32 _assetID, address _sender, uint _amount, uint _price, bool _buyOrder)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, _sender, _amount, _price, _buyOrder));
+ return orderID;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Platform and Contract State
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Platform functions
+ function getPlatformToken()
+ public
+ view
+ returns(address) {
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("platformToken")));
+ return tokenAddress;
+ }
+
+ function getPlatformWallet()
+ public
+ view
+ returns(address) {
+ address walletAddress = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ return walletAddress;
+ }
+
+ function getContractAddress(string _contractName)
+ public
+ view
+ returns(address) {
+ address contractAddress = database.addressStorage(keccak256(abi.encodePacked("contract", _contractName)));
+ return contractAddress;
+ }
+
+ function getCurrentState()
+ public
+ view
+ returns(bytes32) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ return currentState;
+ }
+
+ function getUserPermission(address _investor)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked(getCurrentState(), _investor)));
+ return status;
+ }
+
+ function getFunctionCost(bytes4 _sig, address _contract)
+ public
+ view
+ returns(uint) {
+ uint cost = database.uintStorage(keccak256(abi.encodePacked(_sig, _contract)));
+ return cost;
+ }
+
+ function contractPaused(address _contract)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("paused", _contract)));
+ return status;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Ownership
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function contractOwner(address _account)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("owner", _account)));
+ return status;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 | + + + + + + + + + + + + + +16× + + + + + + + + + + +69× +68× +67× +67× +67× +67× +67× +67× + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + +177× +177× +177× +177× +177× + + + + + + + + + +72× +71× + + + + + + + + + + + +4× +2× + + + +147× +145× + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../interfaces/DBInterface.sol";
+
+// @title A contract manager that determines which contracts have write access to platform database
+// @notice This contract determines which contracts are allowed to make changes to the database contract.
+// @author Kyle Dewhurst, MyBit Foundation
+contract ContractManager{
+ DBInterface public database;
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @notice This function adds new contracts to the platform. Giving them write access to Database.sol
+ // @Param: The name of the contract
+ // @Param: The address of the new contract
+ function addContract(string _name, address _contractAddress)
+ external
+ isTrue(_contractAddress != address(0))
+ isTrue(bytes(_name).length != uint(0))
+ anyOwner {
+ require(!database.boolStorage(keccak256(abi.encodePacked("contract", _contractAddress))));
+ require(database.addressStorage(keccak256(abi.encodePacked("contract", _name))) == address(0));
+ database.setAddress(keccak256(abi.encodePacked("contract", _name)), _contractAddress);
+ database.setBool(keccak256(abi.encodePacked("contract", _contractAddress)), true);
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState"))); //Update currentState
+ bytes32 newState = keccak256(abi.encodePacked(currentState, _contractAddress));
+ database.setBytes32(keccak256(abi.encodePacked("currentState")), newState);
+ emit LogContractAdded(_contractAddress, _name, block.number);
+ }
+
+ // @notice Owner can remove an existing contract on the platform.
+ // @Param: The name of the contract
+ // @Param: The owner who authorized this function to be called
+ function removeContract(string _name)
+ external
+ isTrue(bytes(_name).length != uint(0))
+ contractExists(database.addressStorage(keccak256(abi.encodePacked("contract", _name))))
+ anyOwner {
+ address contractToDelete = database.addressStorage(keccak256(abi.encodePacked("contract", _name)));
+ database.deleteBool(keccak256(abi.encodePacked("contract", contractToDelete)));
+ database.deleteAddress(keccak256(abi.encodePacked("contract", _name)));
+ emit LogContractRemoved(contractToDelete, _name, block.number);
+ }
+
+ // @notice Owner can update an existing contract on the platform, giving it write access to Database
+ // @Param: The name of the contract (First Letter Capitalized)
+ // @Param: The address of the new contract
+ function updateContract(string _name, address _newContractAddress)
+ external
+ isTrue(_newContractAddress != 0)
+ contractExists(database.addressStorage(keccak256(abi.encodePacked("contract", _name))))
+ anyOwner {
+ address oldAddress = database.addressStorage(keccak256(abi.encodePacked("contract", _name)));
+ database.setAddress(keccak256(abi.encodePacked("contract", _name)), _newContractAddress);
+ database.setBool(keccak256(abi.encodePacked("contract", _newContractAddress)), true);
+ database.deleteBool(keccak256(abi.encodePacked("contract", oldAddress)));
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState"))); //Update currentState
+ bytes32 newState = keccak256(abi.encodePacked(currentState, _newContractAddress));
+ database.setBytes32(keccak256(abi.encodePacked("currentState")), newState);
+ emit LogContractUpdated(oldAddress, _name, block.number);
+ emit LogNewContractLocation(_newContractAddress, _name, block.number);
+ }
+
+ // @notice user can decide to accept or deny the current and future state of the platform contracts
+ // @notice if user accepts future upgrades they will automatically be able to interact with upgraded contracts
+ // @param (bool) _acceptCurrentState: does the user agree to use the current contracts in the platform
+ // @param (bool) _ignoreStateChanges: does the user agree to use the platform despite contract changes
+ function setContractStatePreferences(bool _acceptCurrentState, bool _ignoreStateChanges)
+ external
+ returns (bool) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ database.setBool(keccak256(abi.encodePacked(currentState, msg.sender)), _acceptCurrentState);
+ database.setBool(keccak256(abi.encodePacked("ignoreStateChanges", msg.sender)), _ignoreStateChanges);
+ emit LogContractStatePreferenceChanged(msg.sender, _acceptCurrentState, _ignoreStateChanges);
+ return true;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+ // @notice Verify that sender is an owner
+ modifier anyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(database.boolStorage(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)))); // owners must have agreed on function + parameters
+ _;
+ database.deleteBool(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+ modifier contractExists(address _contract) {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", _contract))));
+ _;
+ }
+
+ modifier isTrue(bool _conditional) {
+ require(_conditional);
+ _;
+ }
+
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+ event LogContractAdded(address _contractAddress, string _name, uint _blockNumber);
+ event LogContractRemoved(address contractToDelete, string _name, uint _blockNumber);
+ event LogContractUpdated(address oldAddress, string _name, uint _blockNumber);
+ event LogNewContractLocation(address _contractAddress, string _name, uint _blockNumber);
+ event LogContractStatePreferenceChanged(address indexed _user, bool _currentStateAcceptance, bool _ignoreStateChanges);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 | + + + + + + + + + + + + + + + + + + + + + + +16× +17× +17× + +16× +15× + + + + + + + + +19× +18× +17× +16× +15× +15× + + + + + + +142× + + + + + +67× + + + + + +1× + + + + + +1× + + + + + +87× + + + + + +445× + + + + + +1× + + + + + + + +7× + + + + + +23× + + + + + +1× + + + + + +1× + + + + + +1× + + + + + +7× + + + + + +1× + + + + + + + + + +786× +785× + + + + + + + + | pragma solidity ^0.4.24;
+
+
+// @title A shared storage contract for platform contracts to store and retrieve data
+// @notice This contract holds all long-term data for smart-contract systems
+// @dev The bytes32 hashes are derived from keccak256(variableName, uniqueID) => value
+// @dec Can enable upgradeable contracts by setting a contract manager
+contract Database{
+
+ // Storage Variables
+ mapping(bytes32 => uint) public uintStorage;
+ mapping(bytes32 => string) public stringStorage;
+ mapping(bytes32 => address) public addressStorage;
+ mapping(bytes32 => bytes) public bytesStorage;
+ mapping(bytes32 => bytes32) public bytes32Storage;
+ mapping(bytes32 => bool) public boolStorage;
+ mapping(bytes32 => int) public intStorage;
+
+
+
+ // @notice Constructor: Sets the owners of the platform
+ // @dev Owners must set the contract manager to add more contracts
+ constructor(address[] _owners, bool _upgradeable) public {
+ for(uint i=0; i<_owners.length; i++){
+ boolStorage[keccak256(abi.encodePacked("owner", _owners[i]))] = true;
+ emit LogInitialized(_owners[i], _upgradeable);
+ }
+ if (_upgradeable){
+ boolStorage[keccak256("upgradeable")] = true;
+ }
+ }
+
+
+ // @notice ContractManager will be the only contract that can add/remove contracts on the platform.
+ // @param (address) _contractManager is the contract which can upgrade/remove contracts to platform
+ function enableContractManagement(address _contractManager)
+ external {
+ require(boolStorage[keccak256("upgradeable")]);
+ require(_contractManager != address(0));
+ require(boolStorage[keccak256(abi.encodePacked("owner", msg.sender))]);
+ require(addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] == address(0));
+ addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] = _contractManager;
+ boolStorage[keccak256(abi.encodePacked("contract", _contractManager))] = true;
+ }
+
+ // @notice Storage functions
+ function setAddress(bytes32 _key, address _value)
+ onlyApprovedContract
+ external {
+ addressStorage[_key] = _value;
+ }
+
+ function setUint(bytes32 _key, uint _value)
+ onlyApprovedContract
+ external {
+ uintStorage[_key] = _value;
+ }
+
+ function setString(bytes32 _key, string _value)
+ onlyApprovedContract
+ external {
+ stringStorage[_key] = _value;
+ }
+
+ function setBytes(bytes32 _key, bytes _value)
+ onlyApprovedContract
+ external {
+ bytesStorage[_key] = _value;
+ }
+
+ function setBytes32(bytes32 _key, bytes32 _value)
+ onlyApprovedContract
+ external {
+ bytes32Storage[_key] = _value;
+ }
+
+ function setBool(bytes32 _key, bool _value)
+ onlyApprovedContract
+ external {
+ boolStorage[_key] = _value;
+ }
+
+ function setInt(bytes32 _key, int _value)
+ onlyApprovedContract
+ external {
+ intStorage[_key] = _value;
+ }
+
+
+ // Deletion functions: Can alternatively use setter functions and set to null value (ie. uint = 0)
+ function deleteAddress(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete addressStorage[_key];
+ }
+
+ function deleteUint(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete uintStorage[_key];
+ }
+
+ function deleteString(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete stringStorage[_key];
+ }
+
+ function deleteBytes(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete bytesStorage[_key];
+ }
+
+ function deleteBytes32(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete bytes32Storage[_key];
+ }
+
+ function deleteBool(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete boolStorage[_key];
+ }
+
+ function deleteInt(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete intStorage[_key];
+ }
+
+
+ // --------------------------------------------------------------------------------------
+ // Modifiers
+ // --------------------------------------------------------------------------------------
+
+ // Caller must be registered as a contract through ContractManager.sol
+ modifier onlyApprovedContract() {
+ require(boolStorage[keccak256(abi.encodePacked("contract", msg.sender))]);
+ _;
+ }
+
+ // --------------------------------------------------------------------------------------
+ // Events
+ // --------------------------------------------------------------------------------------
+ event LogInitialized(address _owner, bool _upgradeable);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 | + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import './Database.sol';
+
+contract Events {
+ Database public database;
+ // @dev This will emit the event from the Event contract
+ function numberStored(address _sender, uint _number)
+ external
+ onlyApprovedContract {
+ emit LogFavoriteNumberAdded(_sender, _number);
+ }
+
+ event LogFavoriteNumberAdded(address indexed _sender, uint _number);
+
+
+ // --------------------------------------------------------------------------------------
+ // Caller must be registered as a contract through ContractManager.sol
+ // --------------------------------------------------------------------------------------
+ modifier onlyApprovedContract() {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
+ _;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 | + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+library HashEncode {
+ //Overloaded functions
+ function encode(string _label, bytes32 _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, bytes32 _arg1, bytes32 _arg2) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1, _arg2));
+ }
+ function encode(string _label, bytes32 _arg1, uint _arg2) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1, _arg2));
+ }
+ function encode(string _label, address _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, uint _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, bool _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| API.sol | +36.76% | +25/68 | +100% | +0/0 | +37.84% | +14/37 | +36.76% | +25/68 | +|
| ContractManager.sol | +95% | +19/20 | +83.33% | +10/12 | +88.89% | +8/9 | +91.67% | +33/36 | +|
| Database.sol | +100% | +19/19 | +100% | +12/12 | +100% | +17/17 | +100% | +27/27 | +|
| Events.sol | +0% | +0/2 | +0% | +0/2 | +0% | +0/2 | +0% | +0/3 | +|
| HashEncode.sol | +0% | +0/6 | +100% | +0/0 | +0% | +0/6 | +0% | +0/6 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 | + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + + +4× +4× +3× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + +2× +2× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + + + +4× +3× +3× +2× +2× +2× +2× +2× + + + + + + + + + + + + +3× +3× +2× +2× +2× +2× + + + + + + + + + + + + +3× +3× +2× +1× +1× +1× + +2× +2× + + + + + + + + +1× +1× +1× +1× + + + + + + + + + +3× +2× +1× +1× + + + + + + + + + + + + +10× +9× +8× + + + + + + +10× +9× + + + + + + +11× +10× + + + + + +8× +8× + + + + + + +8× +7× + + + + + + +7× +6× + + + + + + +4× +3× + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/DivToken.sol';
+import "../access/ERC20Burner.sol";
+
+
+// @title Simple decentralized exchange contract
+// @notice A sample contract to implement rudimentary asset-token trading
+// @dev Note: Users can only have 1 sell order and 1 buy order for each individual asset
+// @dev The orders are stored as as sha3 hash of critical parameters to save storage costs
+contract AssetExchange {
+ using SafeMath for uint;
+
+ Database public database;
+ ERC20Burner private burner;
+
+ mapping (address => mapping (bytes32 => bool)) public orders; // Hash of (assetID, sellerAddress, amountToBuy, price, boolean(BuyOrder = true))
+
+ mapping (address => uint) public weiDeposited;
+ mapping (address => uint) public weiOwed;
+ uint private decimals = uint256(1e18);
+
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // Gives Ether sent to initatior of this sellOrder and transfers ownership units of asset to purchaser
+ // Note: Check if creator of sell order has enough ownership units left
+ // @Param: ID of the asset, which these ownershipUnits belong to
+ // @Param: Address of the user who created SellOrder
+ // @Param: Number of ownershipUnits being traded
+ // @Param: The WEI cost per unit
+ function buyAsset(bytes32 _assetID, address _seller, uint _amount, uint _price)
+ external
+ payable
+ whenNotPaused
+ isAllowed(_assetID, _seller, _amount)
+ burnRequired
+ returns (bool){
+ bytes32 thisOrder = keccak256(abi.encodePacked(_assetID, _seller, _amount, _price, false));
+ require(orders[_seller][thisOrder]);
+ require(msg.value == _amount.mul(_price).div(decimals));
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ Erequire(assetToken.transferFrom(_seller, msg.sender, _amount));
+ weiOwed[_seller] = weiOwed[_seller].add(msg.value);
+ delete orders[_seller][thisOrder];
+ emit LogSellOrderCompleted(thisOrder, _assetID, msg.sender);
+ return true;
+ }
+
+ // Settles an open SellOrder, giving the deposited ether to sender and sender tokens to initiator of BuyOrder
+ // @Param: ID of the asset, which senders ownershipUnits belong to
+ // @Param: Address of the user who created BuyOrder
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ function sellAsset(bytes32 _assetID, address _buyer, uint _amount, uint _price)
+ public
+ whenNotPaused
+ isAllowed(_assetID, msg.sender, _amount)
+ returns (bool){
+ bytes32 thisOrder = keccak256(abi.encodePacked(_assetID, _buyer, _amount, _price, true)); // Get order ID
+ require(orders[_buyer][thisOrder]); // Check order exists
+ uint value = _amount.mul(_price).div(decimals);
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ Erequire(assetToken.transferFrom(msg.sender, _buyer, _amount));
+ weiDeposited[_buyer] = weiDeposited[_buyer].sub(value);
+ weiOwed[msg.sender] = weiOwed[msg.sender].add(value);
+ delete orders[_buyer][thisOrder];
+ emit LogBuyOrderCompleted(thisOrder, _assetID, msg.sender);
+ return true;
+ }
+
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset, which the sender wants to purchase ownershipUnits of
+ // @Param: Number of ownershipUnits being bought
+ // @Param: The WEI cost per unit
+ function createBuyOrder(bytes32 _assetID, uint _amount, uint _price)
+ external
+ payable
+ requiresEther
+ aboveZero(_amount, _price)
+ validAsset(_assetID)
+ burnRequired
+ returns (bool) {
+ require(msg.value == _amount.mul(_price).div(decimals));
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, true));
+ require(!orders[msg.sender][orderID]);
+ orders[msg.sender][orderID] = true;
+ weiDeposited[msg.sender] = weiDeposited[msg.sender].add(msg.value);
+ emit LogBuyOrderCreated(orderID, _assetID, msg.sender);
+ emit LogBuyOrderDetails(orderID, _amount, _price);
+ return true;
+ }
+
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset, which sender is trying to sell
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ function createSellOrder(bytes32 _assetID, uint _amount, uint _price)
+ external
+ aboveZero(_amount, _price)
+ validAsset(_assetID)
+ isAllowed(_assetID, msg.sender, _amount)
+ returns (bool) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, false));
+ require(!orders[msg.sender][orderID]);
+ orders[msg.sender][orderID] = true;
+ emit LogSellOrderCreated(orderID, _assetID, msg.sender);
+ emit LogSellOrderDetails(orderID, _amount, _price);
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ // @Param: Is this order a BuyOrder?
+ //------------------------------------------------------------------------------------------------------------------
+ function deleteOrder(bytes32 _assetID, uint _amount, uint _price, bool _buyOrder)
+ external
+ returns (bool) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, _buyOrder));
+ require(orders[msg.sender][orderID]);
+ if (_buyOrder) {
+ uint returnValue = _amount.mul(_price).div(decimals);
+ weiDeposited[msg.sender] = weiDeposited[msg.sender].sub(returnValue);
+ weiOwed[msg.sender] = weiOwed[msg.sender].add(returnValue);
+ }
+ delete orders[msg.sender][orderID];
+ return true;
+ }
+ //------------------------------------------------------------------------------------------------------------------
+ // User can withdraw the wei they are owed here
+ //------------------------------------------------------------------------------------------------------------------
+ function withdraw()
+ external
+ whenNotPaused
+ returns (bool){
+ uint owed = weiOwed[msg.sender];
+ weiOwed[msg.sender] = 0;
+ msg.sender.transfer(owed);
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // @notice Destroys contract and sends WEI to _holdingAddress
+ //------------------------------------------------------------------------------------------------------------------
+ function destroy(address _functionInitiator, address _holdingAddress)
+ anyOwner
+ public {
+ require(_functionInitiator != msg.sender);
+ require(database.boolStorage(keccak256(abi.encodePacked(address(this), _functionInitiator, "destroy", keccak256(abi.encodePacked(_holdingAddress))))));
+ emit LogDestruction(_holdingAddress, address(this).balance, msg.sender);
+ selfdestruct(_holdingAddress);
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // This verifies that the asset is registered on the MyBit Platform and has successfully completed funding
+ //------------------------------------------------------------------------------------------------------------------
+ modifier validAsset(bytes32 _assetID) {
+ require (_assetID != bytes32(0));
+ require (database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Check if user has enough ownershipUnits to create SellOrder
+ //------------------------------------------------------------------------------------------------------------------
+ modifier isAllowed(bytes32 _assetID, address _sender, uint _tokens) {
+ require(DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)))).allowance(_sender, address(this)) >= _tokens);
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verifies that _amount or _price aren't null
+ //------------------------------------------------------------------------------------------------------------------
+ modifier aboveZero(uint _amount, uint _price) {
+ require(_amount.mul(_price) > 0);
+ _;
+ }
+
+ // @notice reverts if user hasn't approved burner to burn platform token
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verify contract isn't paused
+ //------------------------------------------------------------------------------------------------------------------
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Throw if Ether hasn't been sent
+ //------------------------------------------------------------------------------------------------------------------
+ modifier requiresEther() {
+ require(msg.value > 0);
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verify that the sender is a registered owner
+ //------------------------------------------------------------------------------------------------------------------
+ modifier anyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogDestruction(address indexed _locationSent, uint indexed _amountSent, address indexed _caller);
+ event LogBuyOrderCreated(bytes32 _orderID, bytes32 indexed _assetID, address indexed _creator);
+ event LogBuyOrderCompleted(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _purchaser);
+ event LogSellOrderCreated(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _creator);
+ event LogSellOrderCompleted(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _purchaser);
+ event LogBuyOrderDetails(bytes32 _orderID, uint indexed _amount, uint indexed _price);
+ event LogSellOrderDetails(bytes32 orderID, uint indexed _amount, uint indexed _price);
+ event LogownershipUnitsTraded(bytes32 _assetID, address _from, address _to, uint _amount);
+ event LogSig(bytes4 _sig);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + +2× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + +2× +1× +1× +1× +1× +1× +4× + +1× +1× +1× +1× +1× + + + + + +4× +4× +4× + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendToken.sol";
+import "../tokens/distribution/FixedDistribution.sol";
+
+// @title An asset generator contract for onboarding existing real-world assets
+// @author Kyle Dewhurst, MyBit Foundation
+contract AssetGenerator {
+ using SafeMath for uint256;
+
+ DBInterface private database;
+
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ }
+
+
+ // @notice users can on-board non-tradeable assets here
+ // @dev creates an ERC20 dividend token (tradeable) or distribution token (not-tradeable)
+ function createAsset(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ external
+ burnRequired
+ returns (bool) {
+ require (_tokenHolders.length == _amount.length && _tokenHolders.length <= 200);
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _tokenURI));
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", assetID))) == address(0));
+ FixedDistribution assetInstance = new FixedDistribution(_tokenURI, _tokenHolders, _amount);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), address(assetInstance));
+ emit LogAssetCreated(assetID, address(assetInstance), msg.sender, _tokenURI);
+ return true;
+ }
+
+ // @notice users can on-board tradeable assets here
+ // @dev creates an ERC20 dividend token (tradeable) or
+ function createTradeableAsset(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ external
+ burnRequired
+ returns (bool) {
+ require (_tokenHolders.length == _amount.length && _tokenHolders.length <= uint8(200));
+ address assetGeneratorAddress = database.addressStorage(keccak256(abi.encodePacked("contract", "AssetGenerator")));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _tokenURI));
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", assetID))) == address(0));
+ DividendToken assetInstance = new DividendToken(_tokenURI, assetGeneratorAddress); // Gives this contract all new asset tokens
+ for (uint8 i = 0; i < _tokenHolders.length; i++) {
+ assetInstance.mint(_tokenHolders[i], _amount[i]);
+ }
+ assetInstance.finishMinting();
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), address(assetInstance));
+ emit LogTradeableAssetCreated(assetID, address(assetInstance), msg.sender, _tokenURI);
+ return true;
+ }
+
+
+ // @notice reverts if user hasn't approved burner to burn platform token
+ modifier burnRequired {
+ ERC20Burner burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+
+ event LogAssetCreated(bytes32 indexed _assetID, address indexed _tokenAddress, address indexed _assetManager, string _tokenURI);
+ event LogTradeableAssetCreated(bytes32 indexed _assetID, address indexed _tokenAddress, address indexed _assetManager, string _tokenURI);
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 | + + + + + + + + + + +9× + + + + + + + +7× +7× + + + + + + +9× +9× + + + + + + + + +18× +16× + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+contract PlatformFunds {
+
+ Database public database;
+
+ // @notice initialize database
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice owners must set the wallet to receive payments here before initiating crowdsale
+ // @dev will overwrite old wallet address
+ function setPlatformWallet(address _walletAddress)
+ external
+ onlyOwner {
+ database.setAddress(keccak256(abi.encodePacked("platformWallet")), _walletAddress);
+ emit LogPlatformWallet(_walletAddress);
+ }
+
+ // @notice
+ function setPlatformToken(address _tokenAddress)
+ external
+ onlyOwner {
+ database.setAddress(keccak256(abi.encodePacked("platformToken")), _tokenAddress);
+ emit LogPlatformToken(_tokenAddress);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ event LogPlatformWallet(address _platformWallet);
+ event LogPlatformToken(address _platformToken);
+
+
+
+
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+ import "../math/SafeMath.sol";
+ import "../database/Database.sol";
+ import "../interfaces/ERC20.sol";
+ import "../tokens/distribution/MintableDistribution.sol";
+
+
+
+ // @title A contract for investors to loan ERC20 tokens to assetManagers who require escrow
+ // @author Kyle Dewhurst, MyBit Foundation
+ // @notice AssetManager can lock his escrow in this contract and retrieve it if asset funding fails or successfully returns ROI
+ contract Staking {
+
+ Database public database;
+
+
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice AssetManager can request for a staker to lend tokens to cover escrow
+ function requestStaking(string _tokenURI, bytes32 _assetID, uint _amount, uint _sharePercentage)
+ external
+ returns (bool) {
+ bytes32 agreementHash = keccak256(abi.encodePacked(msg.sender, _assetID, _amount, _sharePercentage));
+ database.setBytes32(_assetID, agreementHash);
+ MintableDistribution mintableDistribution = new MintableDistribution(_tokenURI, address(this));
+ database.setAddress(keccak256(abi.encodePacked("stakingMint", _assetID)), address(mintableDistribution));
+ return true;
+ }
+
+ // @notice staker can purchase all of
+ function purchaseStake(bytes32 _assetID, address _requester, uint _amount, uint _sharePercentage)
+ external
+ returns (bool) {
+ bytes32 agreementHash = keccak256(abi.encodePacked(_requester, _assetID, _amount, _sharePercentage));
+ require (database.bytes32Storage(_assetID) == agreementHash);
+ ERC20 stakingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ MintableDistribution distributionToken = MintableDistribution(database.addressStorage(keccak256(abi.encodePacked("stakingMint", _assetID))));
+ bytes32 finalAgreement = keccak256(abi.encodePacked(msg.sender, agreementHash));
+ database.setBytes32(_assetID, finalAgreement);
+ require(stakingToken.transfer(_requester, _amount));
+ require(distributionToken.mint(msg.sender, _amount));
+ require(distributionToken.finishMinting());
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Don't accept null value for bytes32 parameter
+ //------------------------------------------------------------------------------------------------------------------
+ modifier noEmptyBytes(bytes32 _data) {
+ require(_data != bytes32(0));
+ _;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetExchange.sol | +100% | +55/55 | +92.5% | +37/40 | +100% | +15/15 | +100% | +66/66 | +|
| AssetGenerator.sol | +100% | +17/17 | +70% | +7/10 | +100% | +4/4 | +100% | +24/24 | +|
| PlatformFunds.sol | +100% | +4/4 | +100% | +2/2 | +100% | +4/4 | +100% | +7/7 | +|
| Staking.sol | +0% | +0/14 | +0% | +0/10 | +0% | +0/4 | +0% | +0/18 | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| access/ | +100% | +34/34 | +83.33% | +20/24 | +100% | +21/21 | +100% | +47/47 | +|
| crowdsale/ | +93.46% | +100/107 | +68.09% | +64/94 | +88.89% | +32/36 | +93.67% | +148/158 | +|
| database/ | +54.78% | +63/115 | +84.62% | +22/26 | +54.93% | +39/71 | +60.71% | +85/140 | +|
| ecosystem/ | +84.44% | +76/90 | +74.19% | +46/62 | +85.19% | +23/27 | +84.35% | +97/115 | +|
| interfaces/ | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| math/ | +100% | +12/12 | +100% | +8/8 | +100% | +5/5 | +100% | +12/12 | +|
| ownership/ | +32.47% | +25/77 | +37.5% | +9/24 | +41.38% | +12/29 | +32.71% | +35/107 | +|
| roles/ | +73.64% | +81/110 | +44.57% | +41/92 | +90.48% | +19/21 | +77.1% | +101/131 | +|
| test/ | +48.84% | +21/43 | +100% | +4/4 | +45.71% | +16/35 | +46.67% | +21/45 | +|
| tokens/distribution/ | +82.22% | +37/45 | +75% | +6/8 | +83.33% | +15/18 | +82% | +41/50 | +|
| tokens/erc20/ | +91.3% | +147/161 | +80.43% | +37/46 | +88.89% | +48/54 | +89.71% | +157/175 | +
| 1 +2 +3 +4 +5 +6 +7 | + + + + + + | pragma solidity ^0.4.24;
+
+// @notice Receive approval and then execute function
+interface ApproveAndCallFallBack {
+ function receiveApproval(address from, uint tokens, address token, bytes data) external;
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 | + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+interface BurnERC20 {
+
+ function burnFrom(address _tokenHolder, uint _amount) external returns (bool success);
+
+ function burn(uint _amount) external returns (bool success);
+
+ event LogBurn(address indexed _spender, uint256 _value);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 | + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+// @title An interface to interact with Burnable ERC20 tokens
+interface BurnableERC20 {
+
+ function allowance(address tokenOwner, address spender) external view returns (uint remaining);
+
+ function burnFrom(address _tokenHolder, uint _amount) external returns (bool success);
+
+ function burn(uint _amount) external returns (bool success);
+
+ function totalSupply() external view returns (uint256);
+
+ function balanceOf(address _who) external view returns (uint256);
+
+ function transfer(address _to, uint256 _value) external returns (bool);
+
+ function approve(address _spender, uint256 _value) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
+
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+
+ event LogBurn(address indexed _spender, uint256 _value);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+// Database interface
+interface DBInterface {
+
+ function setContractManager(address _contractManager)
+ external;
+
+ // --------------------Set Functions------------------------
+
+ function setAddress(bytes32 _key, address _value)
+ external;
+
+ function setUint(bytes32 _key, uint _value)
+ external;
+
+ function setString(bytes32 _key, string _value)
+ external;
+
+ function setBytes(bytes32 _key, bytes _value)
+ external;
+
+ function setBytes32(bytes32 _key, bytes32 _value)
+ external;
+
+ function setBool(bytes32 _key, bool _value)
+ external;
+
+ function setInt(bytes32 _key, int _value)
+ external;
+
+
+ // -------------- Deletion Functions ------------------
+
+ function deleteAddress(bytes32 _key)
+ external;
+
+ function deleteUint(bytes32 _key)
+ external;
+
+ function deleteString(bytes32 _key)
+ external;
+
+ function deleteBytes(bytes32 _key)
+ external;
+
+ function deleteBytes32(bytes32 _key)
+ external;
+
+ function deleteBool(bytes32 _key)
+ external;
+
+ function deleteInt(bytes32 _key)
+ external;
+
+ // ----------------Variable Getters---------------------
+
+ function uintStorage(bytes32 _key)
+ external
+ view
+ returns (uint);
+
+ function stringStorage(bytes32 _key)
+ external
+ view
+ returns (string);
+
+ function addressStorage(bytes32 _key)
+ external
+ view
+ returns (address);
+
+ function bytesStorage(bytes32 _key)
+ external
+ view
+ returns (bytes);
+
+ function bytes32Storage(bytes32 _key)
+ external
+ view
+ returns (bytes32);
+
+ function boolStorage(bytes32 _key)
+ external
+ view
+ returns (bool);
+
+ function intStorage(bytes32 _key)
+ external
+ view
+ returns (bool);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners receive their share when transferring tokens.
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+// TODO: Suicide function
+interface DivToken {
+
+ // @notice Transfer _amount tokens to address _to.
+ // @dev Sender must have enough tokens. Cannot send to 0x0.
+ // @param (address) _to = The address which will receive the tokens
+ // @param (uint) _amount = The amount of tokens to send
+ function transfer(address _to, uint _amount)
+ external
+ returns (bool success);
+
+ // @notice A 3rd party can transfer tokens if user approves them to do so
+ // @dev Transfer _amount of tokens if _from has allowed msg.sender to do so.
+ // @param (address) _from = The address who approved msg.sender to spend tokens
+ // @param (address) _to = The address who will receive the tokens
+ // @param (uint) _amount = The number of tokens to send
+ function transferFrom(address _from, address _to, uint _amount)
+ external
+ returns (bool success);
+
+ // @notice approves a 3rd party to transfer msg.sender's tokens on behalf of him/her
+ // @param (address) _spender = The address of who msg.sender approves to spend tokens on their behalf
+ // @param (uint) _amount = The upper limit of how many tokens can be spent
+ function approve(address _spender, uint _amount)
+ external
+ returns (bool success);
+
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ external
+ returns (bool success);
+
+ function withdraw()
+ external
+ returns (bool);
+
+ // @notice Updates incomeClaimed, sends all wei to the token holder
+ function collectOwedDividends()
+ external
+ returns (uint _amount);
+
+
+ // @notice Returns amount of tokens _spender is allowed to transfer or burn
+ function allowance(address _tokenHolder, address _spender)
+ external
+ view
+ returns (uint);
+
+ // @notice Returns the number of tokens in circulation
+ function totalSupply()
+ external
+ view
+ returns (uint tokenSupply);
+
+ // @notice Returns the token balance of user
+ function balanceOf(address _tokenHolder)
+ external
+ view
+ returns (uint balance);
+
+ // @notice Returns the URI of this token
+ function tokenURI()
+ external
+ view
+ returns (string);
+
+ function valuePerToken()
+ external
+ view
+ returns (uint);
+
+ function scalingFactor()
+ external
+ view
+ returns (uint);
+
+ // @notice Calculates how much value _user holds
+ function getAmountOwed(address _user)
+ external
+ view
+ returns (uint);
+
+ // @notice Calculates how much wei user is owed. (points + incomeClaimed) / 10**32
+ function getOwedDividends(address _user)
+ external
+ constant
+ returns (uint);
+
+ function assetIncome()
+ external
+ view
+ returns (uint);
+
+ function getERC20()
+ external
+ view
+ returns (address);
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(uint _block, address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 | + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+/**
+ * @title ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+interface ERC20 {
+ function totalSupply() external view returns (uint256);
+
+ function balanceOf(address _who) external view returns (uint256);
+
+ function allowance(address _owner, address _spender) external view returns (uint256);
+
+ function transfer(address _to, uint256 _value) external returns (bool);
+
+ function approve(address _spender, uint256 _value) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
+
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface ERC20DividendInterface{
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount) external returns (bool);
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting() external returns (bool);
+
+ function issueDividends(uint _amount) external;
+
+ // @dev Total number of tokens in existence
+ function totalSupply() external view returns (uint256);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface EtherDividendInterface{
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount) external returns (bool);
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting() external returns (bool);
+
+ function issueDividends() external payable;
+
+ // @dev Total number of tokens in existence
+ function totalSupply() external view returns (uint256);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 | + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+
+interface GovToken {
+
+ function totalSupply() external returns (uint);
+
+ function balanceOf(address _user) external returns (uint);
+
+ function unlockTokens() external returns (bool);
+
+ function lockTokens() external returns (bool);
+
+ function transfer(address _to, uint _amount) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint _amount) external returns (bool);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | + + + + + + + + | pragma solidity ^0.4.24;
+
+// @notice allows contract to call a basic withdraw() function taking no parameters on another contract
+interface PullPayment {
+
+ function withdraw() external returns(bool);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 | + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface TokenFactoryInterface{
+
+ function createEtherDividend(string _tokenURI) external returns (address);
+
+ function createERC20Dividend(string _tokenURI, address _erc20Address) external returns (address);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ApproveAndCallFallback.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| BurnERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| BurnableERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| DBInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| DivToken.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| ERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| ERC20DividendInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| EtherDividendInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| GovToken.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| PullPayment.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| TokenFactoryInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 | + + + + + + + + + + + + + + +4× + + + + + + + + + + +3× +2× +2× +2× + + + + + + + + +2× +2× +2× +2× + + + + + + + +3× +2× + + + + +5× +4× + + + + +13× +10× + + + + +5× +4× + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+// @title A contract for granting and revoking access levels to different users
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice Made for platforms that require hierarchical access restrictions
+contract AccessHierarchy {
+
+ Database public database;
+ uint8 public upperAccessLevel;
+
+ // @notice Constructor: Inititalize Database
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice Owner can manually grant access to a user here. WIll be used for KYC approval
+ // @param Address of new user.
+ // @param The level of access granted by owner/burningcontract
+ function approveUser(address _newUser, uint _accessLevel)
+ onlyPlatform
+ noEmptyAddress(_newUser)
+ public
+ returns (bool) {
+ require(_accessLevel < upperAccessLevel && _accessLevel != uint8(0));
+ database.setUint(keccak256(abi.encodePacked("userAccess", _newUser)), _accessLevel);
+ emit LogUserApproved(_newUser, _accessLevel);
+ return true;
+ }
+
+ // @notice Owner can remove access for users
+ // @param User to be removed
+ function removeUser(address _user)
+ onlyOwner
+ public
+ returns (bool) {
+ uint accessLevel = database.uintStorage(keccak256(abi.encodePacked("userAccess", _user)));
+ database.deleteUint(keccak256(abi.encodePacked("userAccess", _user)));
+ emit LogUserRemoved(_user, accessLevel);
+ return true;
+ }
+
+ // @notice Owner can set the upper bound on access levels
+ // @param (uint8) _newUpperLimit = The highest access level on the platform
+ function setUpperAccessLevel(uint8 _newUpperLimit)
+ public
+ onlyOwner {
+ require(_newUpperLimit > uint8(0));
+ upperAccessLevel = _newUpperLimit;
+ }
+
+ // @notice Deny empty address parameters
+ modifier noEmptyAddress(address _param) {
+ require(_param != address(0));
+ _;
+ }
+
+ // @notice Deny all callers except owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice only contracts on the platform can call.
+ modifier onlyPlatform {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+ event LogUserApproved(address _user, uint _approvalLevel);
+ event LogUserRemoved(address indexed _user, uint indexed _accessLevel);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 | + + + + + + + + + + + + + + + + + + +6× +6× +6× + + + + + + + + + + +40× +39× +39× + + + + + + + + + + + +15× +15× +15× + + + + + + + +1× + + + + + + + + +15× +15× + + + + +45× +43× + + + + +43× +43× +40× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../interfaces/BurnableERC20.sol';
+import "../interfaces/DBInterface.sol";
+
+/// @title A contract for burning ERC20 tokens as usage fee for dapps
+/// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+/// @notice Allows Dapps to call this contract to burn ERC20 tokens as a usage fee
+/// @dev This contract does not accept tokens. It only burns tokens from investors wallets to run platform functionality
+contract ERC20Burner {
+
+ BurnableERC20 public token; // The instance of the ERC20 burner contract
+ DBInterface public database; // The datbase instance
+
+
+ // @notice constructor: initializes database and the MYB token
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ token = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ Erequire(address(token) != address(0));
+ }
+
+ // @notice authorized contracts can burn mybit tokens here if the investor has approved this contract to do so
+ // @param (address) _tokenHolder = the address of the mybit token holder who wishes to burn _amount of tokens
+ // @param (uint) _amount = the amount of tokens to be burnt (must include decimal places)
+ function burn(address _tokenHolder, uint _amount)
+ external
+ onlyPlatformContracts(msg.sender)
+ acceptedState(_tokenHolder)
+ returns (bool) {
+ require(token.burnFrom(_tokenHolder, _amount));
+ emit LogMYBBurned(_tokenHolder, msg.sender, _amount);
+ return true;
+ }
+
+ // @notice owners can set the cost of functionality on the platform here.
+ // @dev _amount will be how many platformTokens are burned to call the method at _contractAddress
+ // @param (bytes4) _methodID: the methodID of the function which is to require a burning fee
+ // @param (address) _contractAddress: the address of the contract where this method is contained
+ function setFee(bytes4 _methodID, address _contractAddress, uint _amount)
+ external
+ onlyOwner
+ returns (bool) {
+ //Sets the price to burn per function in MyB.
+ database.setUint(keccak256(abi.encodePacked(_methodID, _contractAddress)), _amount);
+ emit LogFeeAdded(_contractAddress, _methodID, _amount);
+ return true;
+ }
+
+
+ // @notice fallback function. Rejects all ether
+ function ()
+ external
+ payable {
+ revert();
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice reverts if msg.sender isn't the owner
+ modifier onlyOwner {
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice reverts if address isn't authorized to burn MYB
+ modifier onlyPlatformContracts(address _burner) {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", _burner))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't accepted current contract state or if he doesn't ignore state changes entirely
+ modifier acceptedState(address _investor) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ require(database.boolStorage(keccak256(abi.encodePacked(currentState, _investor))) || database.boolStorage(keccak256(abi.encodePacked("ignoreStateChanges", _investor))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogMYBBurned(address _tokenHolder, address _burningContract, uint _amount);
+ event LogFeeAdded(address indexed _contractAddress, bytes4 _methodID, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + +1× +1× +1× + + + + + + + + +1× +1× +1× + + + + + + | pragma solidity 0.4.24;
+
+
+import '../math/SafeMath.sol';
+import './AccessHierarchy.sol';
+
+// @title A contract extension that gives an expiration date to user access
+// @author Kyle Dewhurst, MyBit Foundation
+contract Expirable is AccessHierarchy {
+ using SafeMath for uint;
+
+ uint public expirationLength = uint256(31557600); // 365 days
+
+ constructor(address _database) public AccessHierarchy(_database){}
+
+ //------------------------------------------------------------------------------------------------------------------
+ // @notice Owner can manually grant access to a user here. WIll be used for KYC approval
+ // @param Address of new user.
+ // @param The level of access granted by owner/burningcontract
+ // TODO: does the modifier in AccessHierarchy throw?
+ //------------------------------------------------------------------------------------------------------------------
+ function approveTemporaryUser(address _newUser, uint _accessLevel)
+ onlyOwner
+ noEmptyAddress(_newUser)
+ public
+ returns (bool) {
+ Erequire(approveUser(_newUser, _accessLevel));
+ uint expiry = now.add(expiry);
+ database.setUint(keccak256(abi.encodePacked("userAccessExpiration", _newUser)), expiry);
+ return true;
+ }
+
+
+ // @notice Owner can remove access for users
+ // @param User to be removed
+ function removeTemporaryUser(address _user)
+ onlyOwner
+ public
+ returns (bool) {
+ Erequire(removeUser(_user));
+ database.deleteUint(keccak256(abi.encodePacked("userAccessExpiration", _user)));
+ return true;
+ }
+
+
+ // @notice Owner can change the length of expiration here
+ // @param (uint) _newExpirationLength = The number of seconds until the access expires
+ function changeExpirationLength(uint _newExpirationLength)
+ external
+ onlyOwner {
+ uint oldExpiration = expirationLength;
+ expirationLength = _newExpirationLength;
+ emit LogExpirationLengthChanged(oldExpiration, expirationLength);
+ }
+
+ event LogExpirationLengthChanged(uint _oldExpirationLength, uint _newExpirationLength);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | + + + + + + + + + + + + + + + +1× +1× + + + + + + +1× + + + + + + | pragma solidity 0.4.24;
+
+import './AccessHierarchy.sol';
+
+// @title A contract that manages KYC approval
+// @notice KYC can be granted or revoked here
+// @author Kyle Dewhurst, MyBit Foundation
+
+contract KYC is AccessHierarchy {
+
+ constructor(address _database) public AccessHierarchy(_database){}
+
+ // @notice Owner can approve KYC for user
+ function approveKYC(address _user)
+ onlyOwner
+ external {
+ database.setBool(keccak256(abi.encodePacked("kycApproved", _user)), true);
+ emit LogKYCApproved(msg.sender, _user);
+ }
+
+ // @notice Owner can approve KYC for user
+ function revokeKYC(address _user)
+ onlyOwner
+ external {
+ database.deleteBool(keccak256(abi.encodePacked("kycApproved", _user)));
+ }
+
+
+ event LogKYCApproved(address _owner, address _user);
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AccessHierarchy.sol | +100% | +12/12 | +100% | +10/10 | +100% | +7/7 | +100% | +17/17 | +|
| ERC20Burner.sol | +100% | +13/13 | +80% | +8/10 | +100% | +7/7 | +100% | +17/17 | +|
| Expirable.sol | +100% | +8/8 | +50% | +2/4 | +100% | +4/4 | +100% | +10/10 | +|
| KYC.sol | +100% | +1/1 | +100% | +0/0 | +100% | +3/3 | +100% | +3/3 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + +5× +5× +5× +5× +5× +3× +3× +3× +3× +3× +3× + + +2× +2× + +4× +4× + + + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + +3× +3× +3× +3× +2× +2× +2× +2× +2× +2× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +3× +3× +3× +3× + + + + + + + + + + + + + + +9× +8× + + + + +5× +5× + + + + +9× +9× + + + + +7× +6× + + + + +2× +1× + + + + +7× +6× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../interfaces/ERC20DividendInterface.sol";
+import "../access/ERC20Burner.sol";
+
+// @title An asset crowdsale contract which accepts funding from ERC20 tokens.
+// @notice Begins a crowdfunding period for a digital asset, minting asset dividend tokens to investors when particular ERC20 token is received
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice creates a dividend token to represent the newly created asset.
+contract CrowdsaleERC20{
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ // @notice Constructor: initializes database instance
+ // @param: The address for the platform database
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+
+ // @notice Investors can send ERC20 tokens here to fund an asset, receiving an equivalent number of asset-tokens.
+ // @dev investor must approve this contract to transfer tokens
+ // @param (bytes32) _assetID = The ID of the asset tokens, investor wishes to purchase
+ // @param (uint) _amount = The amount to spend purchasing this asset
+ function buyAssetOrderERC20(bytes32 _assetID, uint _amount)
+ external
+ validAsset(_assetID)
+ beforeDeadline(_assetID)
+ notFinalized(_assetID)
+ burnRequired
+ returns (bool) {
+ ERC20DividendInterface assetToken = ERC20DividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ uint amountToRaise = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ uint tokensRemaining = amountToRaise.sub(assetToken.totalSupply());
+ if (_amount >= tokensRemaining) {
+ Erequire(fundingToken.transferFrom(msg.sender, address(this), tokensRemaining)); // transfer investors tokens into contract
+ Erequire(assetToken.mint(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))), database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID))) ));
+ Erequire(finalizeCrowdsale(_assetID));
+ Erequire(assetToken.mint(msg.sender, tokensRemaining)); // Send remaining asset tokens to investor
+ Erequire(assetToken.finishMinting());
+ require(payoutERC20(_assetID, amountToRaise)); // 1 token = 1 wei
+ }
+ else {
+ Erequire(fundingToken.transferFrom(msg.sender, address(this), _amount));
+ Erequire(assetToken.mint(msg.sender, _amount));
+ }
+ emit LogAssetPurchased(_assetID, msg.sender, _amount); //Should amount listed be how much they spent or how much they received?
+ return true;
+ }
+
+
+ // @notice Contributors can retrieve their funds here if crowdsale has paased deadline
+ // @param (bytes32) _assetID = The ID of the asset which didn't reach it's crowdfunding goals
+ function refund(bytes32 _assetID)
+ external
+ whenNotPaused
+ validAsset(_assetID)
+ afterDeadline(_assetID)
+ notFinalized(_assetID)
+ returns (bool) {
+ Erequire(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) != 0);
+ database.deleteUint(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ ERC20DividendInterface assetToken = ERC20DividendInterface(tokenAddress);
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ uint refundValue = assetToken.totalSupply(); //token=wei
+ fundingToken.approve(tokenAddress, refundValue);
+ assetToken.issueDividends(refundValue);
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice This is called once funding has succeeded. Sends Ether to a distribution contract where operator/assetManager can withdraw
+ // @dev The contract manager needs to know the address PlatformDistribution contract
+ function payoutERC20(bytes32 _assetID, uint _amount)
+ private
+ whenNotPaused
+ returns (bool) {
+ ERC20 fundingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID))));
+ address operator = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ address platformWallet = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ require(operator != address(0) && platformWallet != address(0));
+ uint operatorPortion = _amount.mul(99).div(100);
+ uint platformPortion = _amount.sub(operatorPortion);
+ fundingToken.transfer(platformWallet, platformPortion);
+ fundingToken.transfer(operator, operatorPortion);
+ emit LogAssetPayout(_assetID, operator, _amount);
+ return true;
+ }
+
+ // @notice platform owners can recover tokens here
+ function recoverTokens(address _erc20Token)
+ onlyOwner
+ external {
+ ERC20 thisToken = ERC20(_erc20Token);
+ uint contractBalance = thisToken.balanceOf(address(this));
+ thisToken.transfer(msg.sender, contractBalance);
+ }
+
+ // @notice platform owners can destroy contract here
+ function destroy()
+ onlyOwner
+ external {
+ emit LogDestruction(address(this).balance, msg.sender);
+ selfdestruct(msg.sender);
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice internal function for freeing up storage after crowdsale finishes
+ // @param the ID of this asset.
+ function finalizeCrowdsale(bytes32 _assetID)
+ internal
+ whenNotPaused
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)), true);
+ database.deleteUint(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerFee", _assetID)));
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice function won't run if owners have paused this contract
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't approved burner to burn platform token
+ modifier burnRequired {
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier beforeDeadline(bytes32 _assetID) {
+ require(now <= database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier afterDeadline(bytes32 _assetID) {
+ require(now > database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice returns true if crowdsale is not finshed
+ modifier notFinalized(bytes32 _assetID) {
+ require( !database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))) );
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogAssetPurchased(bytes32 indexed _assetID, address indexed _sender, uint _amount);
+ event LogAssetPayout(bytes32 indexed _assetID, address indexed _operator, uint _amount);
+ event LogDestruction(uint _amountSent, address indexed _caller);
+ event LogAssetInfo(uint _investorAmount, uint _tokensRemaining);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + +5× +5× +5× +5× + +3× +3× +3× +3× +3× +3× + + +2× + +5× +5× + + + + + + + + + + + + +2× +2× +2× +2× +2× +2× +2× + + + + + + + + + + + + + + + +1× +1× + + + + + + +1× + + + + + + + + + + + + + +3× +3× +3× +3× +3× +3× +3× +3× +3× + + + + + + + +3× +3× +3× +3× + + + + + + + + + + +8× +8× + + + + +2× +1× + + + + +5× +5× + + + + +3× +2× + + + + +10× +10× + + + + +8× +5× + + + + +2× +2× + + + + +7× +7× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../interfaces/EtherDividendInterface.sol";
+import "../access/ERC20Burner.sol";
+
+// @title An asset crowdsale contract, which accepts Ether for funding.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @notice Starts a new crowdsale and returns asset dividend tokens for Wei received.
+// @dev The AssetManager
+contract CrowdsaleETH {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ // @notice Constructor: Initiates the database
+ // @param: The address for the database contract
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+
+ // @notice Investors can send Ether here to fund asset, receiving an equivalent number of asset-tokens.
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ function buyAssetOrderETH(bytes32 _assetID)
+ external
+ payable
+ requiresEther
+ validAsset(_assetID)
+ beforeDeadline(_assetID)
+ notFinalized(_assetID)
+ burnRequired
+ returns (bool) {
+ EtherDividendInterface assetToken = EtherDividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint amountToRaise = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ uint tokensRemaining = amountToRaise.sub(assetToken.totalSupply());
+ if (msg.value >= tokensRemaining) {
+ // Give assetManager his portion of tokens
+ Erequire(assetToken.mint(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))), database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID)))));
+ Erequire(finalizeCrowdsale(_assetID)); // delete unnecessary variables
+ Erequire(assetToken.mint(msg.sender, tokensRemaining)); // Send remaining asset tokens
+ Erequire(assetToken.finishMinting());
+ Erequire(payoutETH(_assetID, amountToRaise)); // 1 token = 1 wei
+ msg.sender.transfer(msg.value.sub(tokensRemaining)); // Return leftover WEI after cost of tokens calculated and subtracted from msg.value
+ }
+ else {
+ Erequire(assetToken.mint(msg.sender, msg.value));
+ }
+ emit LogAssetPurchased(_assetID, msg.sender, msg.value);
+ return true;
+ }
+
+
+ // @notice Contributors can retrieve their funds here if crowdsale has paased deadline and not reached its goal
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ function refund(bytes32 _assetID)
+ external
+ whenNotPaused
+ validAsset(_assetID)
+ afterDeadline(_assetID)
+ notFinalized(_assetID)
+ returns (bool) {
+ Erequire(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) != 0);
+ database.deleteUint(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("investorSupply", _assetID)));
+ EtherDividendInterface assetToken = EtherDividendInterface(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint refundValue = assetToken.totalSupply(); //token=wei
+ assetToken.issueDividends.value(refundValue)();
+ return true;
+ }
+
+ // @notice platform owners can recover tokens here
+ function recoverTokens(address _erc20Token)
+ onlyOwner
+ external {
+ ERC20 thisToken = ERC20(_erc20Token);
+ uint contractBalance = thisToken.balanceOf(address(this));
+ thisToken.transfer(msg.sender, contractBalance);
+ }
+
+ // @notice platform owners can destroy contract here
+ function destroy()
+ onlyOwner
+ external {
+ emit LogDestruction(address(this).balance, msg.sender);
+ selfdestruct(msg.sender);
+ }
+
+ // @notice fallback function: reject ether
+ function ()
+ public
+ payable {
+ revert();
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ // @notice This is called once funding has succeeded. Sends Ether to a distribution contract where operator & assetManager can withdraw
+ // @dev The contract manager needs to know the address PlatformDistribution contract
+ // @param (bytes32) _assetID = The ID of the asset which completed the crowdsale
+ // @param (uint) _amount = The amount of WEI to be sent to the platform + the operator
+ function payoutETH(bytes32 _assetID, uint _amount)
+ internal
+ returns (bool) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ address platformWallet = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ Erequire(operatorAddress != address(0) && platformWallet != address(0));
+ uint operatorPortion = _amount.mul(99).div(100);
+ uint platformPortion = _amount.sub(operatorPortion);
+ platformWallet.transfer(platformPortion);
+ operatorAddress.transfer(operatorPortion);
+ emit LogAssetPayout(_assetID, operatorAddress, _amount);
+ return true;
+ }
+
+ // @notice internal function for freeing up storage after crowdsale finishes
+ // @param the ID of this asset.
+ function finalizeCrowdsale(bytes32 _assetID)
+ internal
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)), true);
+ database.deleteUint(keccak256(abi.encodePacked("amountToRaise", _assetID))); // This is now represented as totalSupply in the asset-token
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerFee", _assetID))); // This is now represented as tokens in AssetManagerFunds.sol
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice Requires that Ether is sent with the transaction
+ modifier requiresEther() {
+ Erequire(msg.value > 0);
+ _;
+ }
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice reverts if investor hasn't approved burner to burn platform token
+ modifier burnRequired {
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ // @notice function won't run if owners have paused this contract
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier beforeDeadline(bytes32 _assetID) {
+ require(now <= database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice reverts if the funding deadline has already past
+ modifier afterDeadline(bytes32 _assetID) {
+ Erequire(now > database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))));
+ _;
+ }
+
+ // @notice returns true if crowdsale is not finshed
+ modifier notFinalized(bytes32 _assetID) {
+ Erequire( !database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))) );
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogAssetPurchased(bytes32 indexed _assetID, address indexed _sender, uint _amount);
+ event LogRefund(bytes32 indexed _assetID, address indexed _funder, uint _amount);
+ event LogAssetPayout(bytes32 indexed _assetID, address indexed _distributionContract, uint _amount);
+ event LogDestruction(uint _amountSent, address indexed _caller);
+ }
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + +6× +5× +5× +5× +4× +4× +3× +3× +3× +3× +3× +3× +3× +3× +3× +3× +3× + + + + + + + + + + +6× +6× + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendTokenERC20.sol";
+
+// @title A crowdsale generator contract
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @notice AssetManagers can initiate a crowdsale that accepts ERC20 tokens as payment here
+contract CrowdsaleGeneratorERC20 {
+ using SafeMath for uint256;
+
+ DBInterface private database;
+ ERC20Burner private burner;
+
+ uint constant scalingFactor = 1e32;
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // @notice AssetManagers can initiate a crowdfund for a new asset here
+ // @dev the crowdsaleERC20 contract is granted rights to mint asset-tokens as it receives funding
+ // @param (string) _assetURI = The location where information about the asset can be found
+ // @param (bytes32) _operatorID = The ID of the operator who is to create and install this asset
+ // @param (uint) _fundingLength = The number of seconds this crowdsale is to go on for until it fails
+ // @param (uint) _amountToRaise = The amount of tokens required to raise for the crowdsale to be a success
+ // @param (uint) _assetManagerPerc = The percentage of the total revenue which is to go to the AssetManager if asset is a success
+ // @param (address) _fundingToken = The ERC20 token to be used to fund the crowdsale (Operator must accept this token as payment)
+ function createAssetOrderERC20(string _assetURI, bytes32 _operatorID, uint _fundingLength, uint _amountToRaise, uint _assetManagerPerc, address _fundingToken)
+ external
+ burnRequired {
+ require(_amountToRaise > 0);
+ Erequire(_assetManagerPerc < 100);
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("acceptsToken", _operatorID, _fundingToken))));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) != address(0));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", assetID))) == 0);
+ address assetAddress = address(new DividendTokenERC20(_assetURI, database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleERC20"))), _fundingToken));
+ database.setUint(keccak256(abi.encodePacked("fundingDeadline", assetID)), now.add(_fundingLength));
+ uint assetManagerFee = _amountToRaise.mul(uint(100).mul(scalingFactor).div(uint(100).sub(_assetManagerPerc)).sub(scalingFactor)).div(scalingFactor);
+ database.setUint(keccak256(abi.encodePacked("amountToRaise", assetID)), _amountToRaise);
+ database.setUint(keccak256(abi.encodePacked("assetManagerFee", assetID)), assetManagerFee);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), assetAddress);
+ database.setBytes32(keccak256(abi.encodePacked("assetTokenID", assetAddress)), assetID);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("operator", assetID)), database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))));
+ database.setAddress(keccak256(abi.encodePacked("fundingToken", assetID)), _fundingToken);
+ emit LogAssetFundingStarted(assetID, msg.sender, _assetURI, assetAddress);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice reverts if AssetManager hasn't approved burner to burn platform token
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogAssetFundingStarted(bytes32 indexed _assetID, address indexed _assetManager, string _assetURI, address indexed _tokenAddress);
+ event LogSig(bytes4 _sig);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 | + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + +9× +8× +7× +7× +6× +6× +5× +5× +5× +5× +5× +5× +5× +5× +5× +5× +5× + + + + + + + + + + +9× +9× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendToken.sol";
+
+// @title A crowdsale generator contract
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice AssetManagers can initiate a crowdsale that accepts Ether as payment here
+contract CrowdsaleGeneratorETH {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+ ERC20Burner public burner;
+
+ uint constant scalingFactor = 1e32; // Used to avoid rounding errors
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // @notice AssetManagers can initiate a crowdfund for a new asset here
+ // @dev the crowdsaleETH contract is granted rights to mint asset-tokens as it receives funding
+ // @param (string) _assetURI = The location where information about the asset can be found
+ // @param (bytes32) _operatorID = The ID of the operator who is to create and install this asset
+ // @param (uint) _fundingLength = The number of seconds this crowdsale is to go on for until it fails
+ // @param (uint) _amountToRaise = The amount of WEI required to raise for the crowdsale to be a success
+ // @param (uint) _assetManagerPerc = The percentage of the total revenue which is to go to the AssetManager if asset is a success
+ function createAssetOrderETH(string _assetURI, bytes32 _operatorID, uint _fundingLength, uint _amountToRaise, uint _assetManagerPerc)
+ external
+ burnRequired
+ returns (bool) {
+ require(_amountToRaise > 0);
+ require(_assetManagerPerc < 100);
+ Erequire(database.boolStorage(keccak256(abi.encodePacked("acceptsEther", _operatorID))));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) != address(0));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", assetID))) == 0);
+ address assetAddress = address(new DividendToken(_assetURI, database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleETH"))))); // Gives this contract all new asset tokens
+ database.setUint(keccak256(abi.encodePacked("fundingDeadline", assetID)), now.add(_fundingLength));
+ uint assetManagerFee = _amountToRaise.mul(uint(100).mul(scalingFactor).div(uint(100).sub(_assetManagerPerc)).sub(scalingFactor)).div(scalingFactor);
+ database.setUint(keccak256(abi.encodePacked("assetManagerFee", assetID)), assetManagerFee);
+ database.setUint(keccak256(abi.encodePacked("amountToRaise", assetID)), _amountToRaise);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), assetAddress);
+ database.setBytes32(keccak256(abi.encodePacked("assetTokenID", assetAddress)), assetID);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("operator", assetID)), database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))));
+ emit LogAssetFundingStarted(assetID, msg.sender, _assetURI, address(assetAddress));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ // @notice reverts if asset manager is unable to burn pp
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogAssetFundingStarted(bytes32 indexed _assetID, address indexed _assetManager, string _assetURI, address indexed _tokenAddress);
+ event LogSig(bytes4 _sig);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| CrowdsaleERC20.sol | +88.37% | +38/43 | +66.67% | +24/36 | +78.57% | +11/14 | +88.14% | +52/59 | +|
| CrowdsaleETH.sol | +94.87% | +37/39 | +61.76% | +21/34 | +93.75% | +15/16 | +94.74% | +54/57 | +|
| CrowdsaleGeneratorERC20.sol | +100% | +12/12 | +75% | +9/12 | +100% | +3/3 | +100% | +21/21 | +|
| CrowdsaleGeneratorETH.sol | +100% | +13/13 | +83.33% | +10/12 | +100% | +3/3 | +100% | +21/21 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +6× + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + + + + +1× + + + + + + +1× +1× + + + + + + +3× + + + + + + +1× + + + + + + +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + +4× +4× + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + +1× + + + + + + +1× +1× +1× + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+import "../math/SafeMath.sol";
+
+interface TokenView {
+ function totalSupply() external view returns (uint);
+ function balanceOf(address _investor) external view returns (uint);
+ function valuePerToken() external view returns (uint);
+ function scalingFactor() external view returns (uint);
+ function assetIncome() external view returns (uint);
+}
+
+interface DBView {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function stringStorage(bytes32 _key) external view returns (string);
+ function addressStorage(bytes32 _key) external view returns (address);
+ function bytesStorage(bytes32 _key) external view returns (bytes);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+ function boolStorage(bytes32 _key) external view returns (bool);
+ function intStorage(bytes32 _key) external view returns (bool);
+}
+
+// @title A contract that gets variables from the _database
+// @notice The API contract can only view the database. It has no write privileges
+contract API {
+ using SafeMath for uint256;
+
+ DBView private database;
+
+ constructor(address _database)
+ public {
+ database = DBView(_database);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Governance + Function ID's
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ // @notice returns the amount of tokens unlocked and free to spend for _ser
+ function getNumTokensAvailable(bytes32 _assetID, address _investor)
+ public
+ view
+ returns (uint) {
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)));
+ address assetToken = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ uint balance = TokenView(assetToken).balanceOf(_investor);
+ return balance.sub(amountLocked);
+ }
+
+ function getInvestorVotes(bytes32 _executionID, address _investor)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("investorVotes", _executionID, _investor)));
+ }
+
+ function getTotalVotes(bytes32 _executionID)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("voteTotal", _executionID)));
+ }
+
+ function getCurrentConsensus(bytes32 _executionID, address _assetToken)
+ public
+ view
+ returns (uint) {
+ uint totalVotes = getTotalVotes(_executionID);
+ return (totalVotes * 100) / TokenView(_assetToken).totalSupply();
+ }
+
+ function getAssetManagerParameterHash(bytes32 _assetID, address _oldAssetManager, address _newAssetManager, uint _amount, bool _burn)
+ public
+ pure
+ returns (bytes32){
+ return keccak256(abi.encodePacked(_assetID, _oldAssetManager, _newAssetManager, _amount, _burn));
+ }
+
+ function getExecutionID(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ }
+
+ function getMethodID(string _functionString)
+ public
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked(_functionString)));
+ }
+
+ function getAssetID(address _broker, string _assetURI, uint _amountToRaise, bytes32 _operatorID)
+ public
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_broker, _amountToRaise, _operatorID, _assetURI));
+ }
+
+ function getOrderID(bytes _assetID, address _investor, uint _amount, uint _price, bool _buyOrder)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_assetID, _investor, _amount, _price, _buyOrder));
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Crowdsale and Assets
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ function generateAssetID(address _broker, uint _amountToRaise, bytes32 _operatorID, string _assetURI)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 assetID = keccak256(abi.encodePacked(_broker, _amountToRaise, _operatorID, _assetURI));
+ return assetID;
+ }
+
+ function getAssetID(address _tokenAddress)
+ public
+ view
+ returns(bytes32) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", _tokenAddress)));
+ return assetID;
+ }
+
+ function getAssetAddress(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address assetAddress = database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)));
+ return assetAddress;
+ }
+
+ function getAssetFundingToken(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address fundingTokenAddress = database.addressStorage(keccak256(abi.encodePacked("fundingToken", _assetID)));
+ return fundingTokenAddress;
+ }
+
+ // IF we decide not to store assetIncome
+ // function getAssetIncome(bytes32 _assetID)
+ // public
+ // view
+ // returns (uint) {
+ // TokenView asset = TokenView(getAssetAddress(_assetID));
+ // uint valuePerToken = asset.valuePerToken();
+ // return (valuePerToken * (asset.totalSupply())) / asset.scalingFactor();
+ // }
+
+ function getAssetROI(bytes32 _assetID)
+ public
+ view
+ returns (uint) {
+ TokenView assetToken = TokenView(getAssetAddress(_assetID));
+ return (assetToken.assetIncome() * 100) / assetToken.totalSupply();
+ }
+
+ function getAssetFundingGoal(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint fundingGoal = database.uintStorage(keccak256(abi.encodePacked("amountToRaise", _assetID)));
+ return fundingGoal;
+ }
+
+ function getAssetFundingDeadline(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint fundingDeadline = database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID)));
+ return fundingDeadline;
+ }
+
+ function crowdsaleFinalized(bytes32 _assetID)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)));
+ return status;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Asset Manager and Operator
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function getAssetManager(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address managerAddress = database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID)));
+ return managerAddress;
+ }
+
+ function getAssetManagerFee(bytes32 _assetID)
+ public
+ view
+ returns(uint) {
+ uint managerFee = database.uintStorage(keccak256(abi.encodePacked("assetManagerFee", _assetID)));
+ return managerFee;
+ }
+
+ function getAssetManagerEscrowID(bytes32 _assetID, address _manager)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 managerEscrowID = keccak256(abi.encodePacked(_assetID, _manager));
+ return managerEscrowID;
+ }
+
+ function getAssetManagerEscrow(bytes32 _managerEscrowID)
+ public
+ view
+ returns (uint) {
+ return database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", _managerEscrowID)));
+ }
+
+ function getAssetManagerEscrowRemaining(bytes32 _managerEscrowID)
+ public
+ view
+ returns(uint) {
+ uint redeemed = getAssetManagerEscrowRedeemed(_managerEscrowID);
+ uint brokerEscrow = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", _managerEscrowID))).sub(redeemed);
+ return brokerEscrow;
+ }
+
+ function getAssetManagerEscrowRedeemed(bytes32 _managerEscrowID)
+ public
+ view
+ returns(uint) {
+ uint escrowRedeemed = database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", _managerEscrowID)));
+ return escrowRedeemed;
+ }
+
+ function getAssetOperator(bytes32 _assetID)
+ public
+ view
+ returns(address) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _assetID)));
+ return operatorAddress;
+ }
+
+ function generateOperatorID(string _operatorURI)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 operatorID = keccak256(abi.encodePacked(_operatorURI));
+ return operatorID;
+ }
+
+ function getOperatorID(address _operatorAddress)
+ public
+ view
+ returns(bytes32) {
+ bytes32 operatorID = database.bytes32Storage(keccak256(abi.encodePacked("operator", _operatorAddress)));
+ return operatorID;
+ }
+
+ function getOperatorAddress(bytes32 _operatorID)
+ public
+ view
+ returns(address) {
+ address operatorAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
+ return operatorAddress;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Stakeholders
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function generateOrderID(bytes32 _assetID, address _sender, uint _amount, uint _price, bool _buyOrder)
+ public
+ pure
+ returns(bytes32) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, _sender, _amount, _price, _buyOrder));
+ return orderID;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Platform and Contract State
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Platform functions
+ function getPlatformToken()
+ public
+ view
+ returns(address) {
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("platformToken")));
+ return tokenAddress;
+ }
+
+ function getPlatformWallet()
+ public
+ view
+ returns(address) {
+ address walletAddress = database.addressStorage(keccak256(abi.encodePacked("platformWallet")));
+ return walletAddress;
+ }
+
+ function getContractAddress(string _contractName)
+ public
+ view
+ returns(address) {
+ address contractAddress = database.addressStorage(keccak256(abi.encodePacked("contract", _contractName)));
+ return contractAddress;
+ }
+
+ function getCurrentState()
+ public
+ view
+ returns(bytes32) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ return currentState;
+ }
+
+ function getUserPermission(address _investor)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked(getCurrentState(), _investor)));
+ return status;
+ }
+
+ function getFunctionCost(bytes4 _sig, address _contract)
+ public
+ view
+ returns(uint) {
+ uint cost = database.uintStorage(keccak256(abi.encodePacked(_sig, _contract)));
+ return cost;
+ }
+
+ function contractPaused(address _contract)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("paused", _contract)));
+ return status;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Ownership
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ function contractOwner(address _account)
+ public
+ view
+ returns(bool) {
+ bool status = database.boolStorage(keccak256(abi.encodePacked("owner", _account)));
+ return status;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 | + + + + + + + + + + + + + +16× + + + + + + + + + + +69× +68× +67× +67× +67× +67× +67× +67× + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + +177× +177× +177× +177× +177× + + + + + + + + + +72× +71× + + + + + + + + + + + +4× +2× + + + +147× +145× + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../interfaces/DBInterface.sol";
+
+// @title A contract manager that determines which contracts have write access to platform database
+// @notice This contract determines which contracts are allowed to make changes to the database contract.
+// @author Kyle Dewhurst, MyBit Foundation
+contract ContractManager{
+ DBInterface public database;
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @notice This function adds new contracts to the platform. Giving them write access to Database.sol
+ // @Param: The name of the contract
+ // @Param: The address of the new contract
+ function addContract(string _name, address _contractAddress)
+ external
+ isTrue(_contractAddress != address(0))
+ isTrue(bytes(_name).length != uint(0))
+ anyOwner {
+ require(!database.boolStorage(keccak256(abi.encodePacked("contract", _contractAddress))));
+ require(database.addressStorage(keccak256(abi.encodePacked("contract", _name))) == address(0));
+ database.setAddress(keccak256(abi.encodePacked("contract", _name)), _contractAddress);
+ database.setBool(keccak256(abi.encodePacked("contract", _contractAddress)), true);
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState"))); //Update currentState
+ bytes32 newState = keccak256(abi.encodePacked(currentState, _contractAddress));
+ database.setBytes32(keccak256(abi.encodePacked("currentState")), newState);
+ emit LogContractAdded(_contractAddress, _name, block.number);
+ }
+
+ // @notice Owner can remove an existing contract on the platform.
+ // @Param: The name of the contract
+ // @Param: The owner who authorized this function to be called
+ function removeContract(string _name)
+ external
+ isTrue(bytes(_name).length != uint(0))
+ contractExists(database.addressStorage(keccak256(abi.encodePacked("contract", _name))))
+ anyOwner {
+ address contractToDelete = database.addressStorage(keccak256(abi.encodePacked("contract", _name)));
+ database.deleteBool(keccak256(abi.encodePacked("contract", contractToDelete)));
+ database.deleteAddress(keccak256(abi.encodePacked("contract", _name)));
+ emit LogContractRemoved(contractToDelete, _name, block.number);
+ }
+
+ // @notice Owner can update an existing contract on the platform, giving it write access to Database
+ // @Param: The name of the contract (First Letter Capitalized)
+ // @Param: The address of the new contract
+ function updateContract(string _name, address _newContractAddress)
+ external
+ isTrue(_newContractAddress != 0)
+ contractExists(database.addressStorage(keccak256(abi.encodePacked("contract", _name))))
+ anyOwner {
+ address oldAddress = database.addressStorage(keccak256(abi.encodePacked("contract", _name)));
+ database.setAddress(keccak256(abi.encodePacked("contract", _name)), _newContractAddress);
+ database.setBool(keccak256(abi.encodePacked("contract", _newContractAddress)), true);
+ database.deleteBool(keccak256(abi.encodePacked("contract", oldAddress)));
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState"))); //Update currentState
+ bytes32 newState = keccak256(abi.encodePacked(currentState, _newContractAddress));
+ database.setBytes32(keccak256(abi.encodePacked("currentState")), newState);
+ emit LogContractUpdated(oldAddress, _name, block.number);
+ emit LogNewContractLocation(_newContractAddress, _name, block.number);
+ }
+
+ // @notice user can decide to accept or deny the current and future state of the platform contracts
+ // @notice if user accepts future upgrades they will automatically be able to interact with upgraded contracts
+ // @param (bool) _acceptCurrentState: does the user agree to use the current contracts in the platform
+ // @param (bool) _ignoreStateChanges: does the user agree to use the platform despite contract changes
+ function setContractStatePreferences(bool _acceptCurrentState, bool _ignoreStateChanges)
+ external
+ returns (bool) {
+ bytes32 currentState = database.bytes32Storage(keccak256(abi.encodePacked("currentState")));
+ database.setBool(keccak256(abi.encodePacked(currentState, msg.sender)), _acceptCurrentState);
+ database.setBool(keccak256(abi.encodePacked("ignoreStateChanges", msg.sender)), _ignoreStateChanges);
+ emit LogContractStatePreferenceChanged(msg.sender, _acceptCurrentState, _ignoreStateChanges);
+ return true;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+ // @notice Verify that sender is an owner
+ modifier anyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(database.boolStorage(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)))); // owners must have agreed on function + parameters
+ _;
+ database.deleteBool(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+ modifier contractExists(address _contract) {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", _contract))));
+ _;
+ }
+
+ modifier isTrue(bool _conditional) {
+ require(_conditional);
+ _;
+ }
+
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+ event LogContractAdded(address _contractAddress, string _name, uint _blockNumber);
+ event LogContractRemoved(address contractToDelete, string _name, uint _blockNumber);
+ event LogContractUpdated(address oldAddress, string _name, uint _blockNumber);
+ event LogNewContractLocation(address _contractAddress, string _name, uint _blockNumber);
+ event LogContractStatePreferenceChanged(address indexed _user, bool _currentStateAcceptance, bool _ignoreStateChanges);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 | + + + + + + + + + + + + + + + + + + + + + + +16× +17× +17× + +16× +15× + + + + + + + + +19× +18× +17× +16× +15× +15× + + + + + + +142× + + + + + +67× + + + + + +1× + + + + + +1× + + + + + +87× + + + + + +445× + + + + + +1× + + + + + + + +7× + + + + + +23× + + + + + +1× + + + + + +1× + + + + + +1× + + + + + +7× + + + + + +1× + + + + + + + + + +786× +785× + + + + + + + + | pragma solidity ^0.4.24;
+
+
+// @title A shared storage contract for platform contracts to store and retrieve data
+// @notice This contract holds all long-term data for smart-contract systems
+// @dev The bytes32 hashes are derived from keccak256(variableName, uniqueID) => value
+// @dec Can enable upgradeable contracts by setting a contract manager
+contract Database{
+
+ // Storage Variables
+ mapping(bytes32 => uint) public uintStorage;
+ mapping(bytes32 => string) public stringStorage;
+ mapping(bytes32 => address) public addressStorage;
+ mapping(bytes32 => bytes) public bytesStorage;
+ mapping(bytes32 => bytes32) public bytes32Storage;
+ mapping(bytes32 => bool) public boolStorage;
+ mapping(bytes32 => int) public intStorage;
+
+
+
+ // @notice Constructor: Sets the owners of the platform
+ // @dev Owners must set the contract manager to add more contracts
+ constructor(address[] _owners, bool _upgradeable) public {
+ for(uint i=0; i<_owners.length; i++){
+ boolStorage[keccak256(abi.encodePacked("owner", _owners[i]))] = true;
+ emit LogInitialized(_owners[i], _upgradeable);
+ }
+ if (_upgradeable){
+ boolStorage[keccak256("upgradeable")] = true;
+ }
+ }
+
+
+ // @notice ContractManager will be the only contract that can add/remove contracts on the platform.
+ // @param (address) _contractManager is the contract which can upgrade/remove contracts to platform
+ function enableContractManagement(address _contractManager)
+ external {
+ require(boolStorage[keccak256("upgradeable")]);
+ require(_contractManager != address(0));
+ require(boolStorage[keccak256(abi.encodePacked("owner", msg.sender))]);
+ require(addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] == address(0));
+ addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] = _contractManager;
+ boolStorage[keccak256(abi.encodePacked("contract", _contractManager))] = true;
+ }
+
+ // @notice Storage functions
+ function setAddress(bytes32 _key, address _value)
+ onlyApprovedContract
+ external {
+ addressStorage[_key] = _value;
+ }
+
+ function setUint(bytes32 _key, uint _value)
+ onlyApprovedContract
+ external {
+ uintStorage[_key] = _value;
+ }
+
+ function setString(bytes32 _key, string _value)
+ onlyApprovedContract
+ external {
+ stringStorage[_key] = _value;
+ }
+
+ function setBytes(bytes32 _key, bytes _value)
+ onlyApprovedContract
+ external {
+ bytesStorage[_key] = _value;
+ }
+
+ function setBytes32(bytes32 _key, bytes32 _value)
+ onlyApprovedContract
+ external {
+ bytes32Storage[_key] = _value;
+ }
+
+ function setBool(bytes32 _key, bool _value)
+ onlyApprovedContract
+ external {
+ boolStorage[_key] = _value;
+ }
+
+ function setInt(bytes32 _key, int _value)
+ onlyApprovedContract
+ external {
+ intStorage[_key] = _value;
+ }
+
+
+ // Deletion functions: Can alternatively use setter functions and set to null value (ie. uint = 0)
+ function deleteAddress(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete addressStorage[_key];
+ }
+
+ function deleteUint(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete uintStorage[_key];
+ }
+
+ function deleteString(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete stringStorage[_key];
+ }
+
+ function deleteBytes(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete bytesStorage[_key];
+ }
+
+ function deleteBytes32(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete bytes32Storage[_key];
+ }
+
+ function deleteBool(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete boolStorage[_key];
+ }
+
+ function deleteInt(bytes32 _key)
+ onlyApprovedContract
+ external {
+ delete intStorage[_key];
+ }
+
+
+ // --------------------------------------------------------------------------------------
+ // Modifiers
+ // --------------------------------------------------------------------------------------
+
+ // Caller must be registered as a contract through ContractManager.sol
+ modifier onlyApprovedContract() {
+ require(boolStorage[keccak256(abi.encodePacked("contract", msg.sender))]);
+ _;
+ }
+
+ // --------------------------------------------------------------------------------------
+ // Events
+ // --------------------------------------------------------------------------------------
+ event LogInitialized(address _owner, bool _upgradeable);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 | + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import './Database.sol';
+
+contract Events {
+ Database public database;
+ // @dev This will emit the event from the Event contract
+ function numberStored(address _sender, uint _number)
+ external
+ onlyApprovedContract {
+ emit LogFavoriteNumberAdded(_sender, _number);
+ }
+
+ event LogFavoriteNumberAdded(address indexed _sender, uint _number);
+
+
+ // --------------------------------------------------------------------------------------
+ // Caller must be registered as a contract through ContractManager.sol
+ // --------------------------------------------------------------------------------------
+ modifier onlyApprovedContract() {
+ require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
+ _;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 | + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+library HashEncode {
+ //Overloaded functions
+ function encode(string _label, bytes32 _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, bytes32 _arg1, bytes32 _arg2) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1, _arg2));
+ }
+ function encode(string _label, bytes32 _arg1, uint _arg2) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1, _arg2));
+ }
+ function encode(string _label, address _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, uint _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+ function encode(string _label, bool _arg1) pure public returns(bytes32){
+ return keccak256(abi.encodePacked(_label, _arg1));
+ }
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| API.sol | +36.76% | +25/68 | +100% | +0/0 | +37.84% | +14/37 | +36.76% | +25/68 | +|
| ContractManager.sol | +95% | +19/20 | +83.33% | +10/12 | +88.89% | +8/9 | +91.67% | +33/36 | +|
| Database.sol | +100% | +19/19 | +100% | +12/12 | +100% | +17/17 | +100% | +27/27 | +|
| Events.sol | +0% | +0/2 | +0% | +0/2 | +0% | +0/2 | +0% | +0/3 | +|
| HashEncode.sol | +0% | +0/6 | +100% | +0/0 | +0% | +0/6 | +0% | +0/6 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 | + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +2× + + + + + + + + + + + + + + + +4× +4× +3× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + +2× +2× +1× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + + + + + + + +4× +3× +3× +2× +2× +2× +2× +2× + + + + + + + + + + + + +3× +3× +2× +2× +2× +2× + + + + + + + + + + + + +3× +3× +2× +1× +1× +1× + +2× +2× + + + + + + + + +1× +1× +1× +1× + + + + + + + + + +3× +2× +1× +1× + + + + + + + + + + + + +10× +9× +8× + + + + + + +10× +9× + + + + + + +11× +10× + + + + + +8× +8× + + + + + + +8× +7× + + + + + + +7× +6× + + + + + + +4× +3× + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/DivToken.sol';
+import "../access/ERC20Burner.sol";
+
+
+// @title Simple decentralized exchange contract
+// @notice A sample contract to implement rudimentary asset-token trading
+// @dev Note: Users can only have 1 sell order and 1 buy order for each individual asset
+// @dev The orders are stored as as sha3 hash of critical parameters to save storage costs
+contract AssetExchange {
+ using SafeMath for uint;
+
+ Database public database;
+ ERC20Burner private burner;
+
+ mapping (address => mapping (bytes32 => bool)) public orders; // Hash of (assetID, sellerAddress, amountToBuy, price, boolean(BuyOrder = true))
+
+ mapping (address => uint) public weiDeposited;
+ mapping (address => uint) public weiOwed;
+ uint private decimals = uint256(1e18);
+
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ }
+
+ // Gives Ether sent to initatior of this sellOrder and transfers ownership units of asset to purchaser
+ // Note: Check if creator of sell order has enough ownership units left
+ // @Param: ID of the asset, which these ownershipUnits belong to
+ // @Param: Address of the user who created SellOrder
+ // @Param: Number of ownershipUnits being traded
+ // @Param: The WEI cost per unit
+ function buyAsset(bytes32 _assetID, address _seller, uint _amount, uint _price)
+ external
+ payable
+ whenNotPaused
+ isAllowed(_assetID, _seller, _amount)
+ burnRequired
+ returns (bool){
+ bytes32 thisOrder = keccak256(abi.encodePacked(_assetID, _seller, _amount, _price, false));
+ require(orders[_seller][thisOrder]);
+ require(msg.value == _amount.mul(_price).div(decimals));
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ Erequire(assetToken.transferFrom(_seller, msg.sender, _amount));
+ weiOwed[_seller] = weiOwed[_seller].add(msg.value);
+ delete orders[_seller][thisOrder];
+ emit LogSellOrderCompleted(thisOrder, _assetID, msg.sender);
+ return true;
+ }
+
+ // Settles an open SellOrder, giving the deposited ether to sender and sender tokens to initiator of BuyOrder
+ // @Param: ID of the asset, which senders ownershipUnits belong to
+ // @Param: Address of the user who created BuyOrder
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ function sellAsset(bytes32 _assetID, address _buyer, uint _amount, uint _price)
+ public
+ whenNotPaused
+ isAllowed(_assetID, msg.sender, _amount)
+ returns (bool){
+ bytes32 thisOrder = keccak256(abi.encodePacked(_assetID, _buyer, _amount, _price, true)); // Get order ID
+ require(orders[_buyer][thisOrder]); // Check order exists
+ uint value = _amount.mul(_price).div(decimals);
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ Erequire(assetToken.transferFrom(msg.sender, _buyer, _amount));
+ weiDeposited[_buyer] = weiDeposited[_buyer].sub(value);
+ weiOwed[msg.sender] = weiOwed[msg.sender].add(value);
+ delete orders[_buyer][thisOrder];
+ emit LogBuyOrderCompleted(thisOrder, _assetID, msg.sender);
+ return true;
+ }
+
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset, which the sender wants to purchase ownershipUnits of
+ // @Param: Number of ownershipUnits being bought
+ // @Param: The WEI cost per unit
+ function createBuyOrder(bytes32 _assetID, uint _amount, uint _price)
+ external
+ payable
+ requiresEther
+ aboveZero(_amount, _price)
+ validAsset(_assetID)
+ burnRequired
+ returns (bool) {
+ require(msg.value == _amount.mul(_price).div(decimals));
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, true));
+ require(!orders[msg.sender][orderID]);
+ orders[msg.sender][orderID] = true;
+ weiDeposited[msg.sender] = weiDeposited[msg.sender].add(msg.value);
+ emit LogBuyOrderCreated(orderID, _assetID, msg.sender);
+ emit LogBuyOrderDetails(orderID, _amount, _price);
+ return true;
+ }
+
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset, which sender is trying to sell
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ function createSellOrder(bytes32 _assetID, uint _amount, uint _price)
+ external
+ aboveZero(_amount, _price)
+ validAsset(_assetID)
+ isAllowed(_assetID, msg.sender, _amount)
+ returns (bool) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, false));
+ require(!orders[msg.sender][orderID]);
+ orders[msg.sender][orderID] = true;
+ emit LogSellOrderCreated(orderID, _assetID, msg.sender);
+ emit LogSellOrderDetails(orderID, _amount, _price);
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Create a BuyOrder and leave WEI as a deposit for user that picks up order
+ // @Param: ID of the asset
+ // @Param: Number of ownershipUnits being sold
+ // @Param: The WEI cost per unit
+ // @Param: Is this order a BuyOrder?
+ //------------------------------------------------------------------------------------------------------------------
+ function deleteOrder(bytes32 _assetID, uint _amount, uint _price, bool _buyOrder)
+ external
+ returns (bool) {
+ bytes32 orderID = keccak256(abi.encodePacked(_assetID, msg.sender, _amount, _price, _buyOrder));
+ require(orders[msg.sender][orderID]);
+ if (_buyOrder) {
+ uint returnValue = _amount.mul(_price).div(decimals);
+ weiDeposited[msg.sender] = weiDeposited[msg.sender].sub(returnValue);
+ weiOwed[msg.sender] = weiOwed[msg.sender].add(returnValue);
+ }
+ delete orders[msg.sender][orderID];
+ return true;
+ }
+ //------------------------------------------------------------------------------------------------------------------
+ // User can withdraw the wei they are owed here
+ //------------------------------------------------------------------------------------------------------------------
+ function withdraw()
+ external
+ whenNotPaused
+ returns (bool){
+ uint owed = weiOwed[msg.sender];
+ weiOwed[msg.sender] = 0;
+ msg.sender.transfer(owed);
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // @notice Destroys contract and sends WEI to _holdingAddress
+ //------------------------------------------------------------------------------------------------------------------
+ function destroy(address _functionInitiator, address _holdingAddress)
+ anyOwner
+ public {
+ require(_functionInitiator != msg.sender);
+ require(database.boolStorage(keccak256(abi.encodePacked(address(this), _functionInitiator, "destroy", keccak256(abi.encodePacked(_holdingAddress))))));
+ emit LogDestruction(_holdingAddress, address(this).balance, msg.sender);
+ selfdestruct(_holdingAddress);
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // This verifies that the asset is registered on the MyBit Platform and has successfully completed funding
+ //------------------------------------------------------------------------------------------------------------------
+ modifier validAsset(bytes32 _assetID) {
+ require (_assetID != bytes32(0));
+ require (database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Check if user has enough ownershipUnits to create SellOrder
+ //------------------------------------------------------------------------------------------------------------------
+ modifier isAllowed(bytes32 _assetID, address _sender, uint _tokens) {
+ require(DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)))).allowance(_sender, address(this)) >= _tokens);
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verifies that _amount or _price aren't null
+ //------------------------------------------------------------------------------------------------------------------
+ modifier aboveZero(uint _amount, uint _price) {
+ require(_amount.mul(_price) > 0);
+ _;
+ }
+
+ // @notice reverts if user hasn't approved burner to burn platform token
+ modifier burnRequired {
+ //emit LogSig(msg.sig);
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verify contract isn't paused
+ //------------------------------------------------------------------------------------------------------------------
+ modifier whenNotPaused {
+ require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Throw if Ether hasn't been sent
+ //------------------------------------------------------------------------------------------------------------------
+ modifier requiresEther() {
+ require(msg.value > 0);
+ _;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Verify that the sender is a registered owner
+ //------------------------------------------------------------------------------------------------------------------
+ modifier anyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+ event LogDestruction(address indexed _locationSent, uint indexed _amountSent, address indexed _caller);
+ event LogBuyOrderCreated(bytes32 _orderID, bytes32 indexed _assetID, address indexed _creator);
+ event LogBuyOrderCompleted(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _purchaser);
+ event LogSellOrderCreated(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _creator);
+ event LogSellOrderCompleted(bytes32 _orderID, bytes32 indexed _assetAddress, address indexed _purchaser);
+ event LogBuyOrderDetails(bytes32 _orderID, uint indexed _amount, uint indexed _price);
+ event LogSellOrderDetails(bytes32 orderID, uint indexed _amount, uint indexed _price);
+ event LogownershipUnitsTraded(bytes32 _assetID, address _from, address _to, uint _amount);
+ event LogSig(bytes4 _sig);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 | + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + +2× +1× +1× +1× +1× +1× +1× +1× + + + + + + + + +2× +1× +1× +1× +1× +1× +4× + +1× +1× +1× +1× +1× + + + + + +4× +4× +4× + + + + + + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+import "../interfaces/DBInterface.sol";
+import "../access/ERC20Burner.sol";
+import "../tokens/erc20/DividendToken.sol";
+import "../tokens/distribution/FixedDistribution.sol";
+
+// @title An asset generator contract for onboarding existing real-world assets
+// @author Kyle Dewhurst, MyBit Foundation
+contract AssetGenerator {
+ using SafeMath for uint256;
+
+ DBInterface private database;
+
+
+ // @notice This contract
+ // @param: The address for the database contract used by this platform
+ constructor(address _database)
+ public{
+ database = DBInterface(_database);
+ }
+
+
+ // @notice users can on-board non-tradeable assets here
+ // @dev creates an ERC20 dividend token (tradeable) or distribution token (not-tradeable)
+ function createAsset(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ external
+ burnRequired
+ returns (bool) {
+ require (_tokenHolders.length == _amount.length && _tokenHolders.length <= 200);
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _tokenURI));
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", assetID))) == address(0));
+ FixedDistribution assetInstance = new FixedDistribution(_tokenURI, _tokenHolders, _amount);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), address(assetInstance));
+ emit LogAssetCreated(assetID, address(assetInstance), msg.sender, _tokenURI);
+ return true;
+ }
+
+ // @notice users can on-board tradeable assets here
+ // @dev creates an ERC20 dividend token (tradeable) or
+ function createTradeableAsset(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ external
+ burnRequired
+ returns (bool) {
+ require (_tokenHolders.length == _amount.length && _tokenHolders.length <= uint8(200));
+ address assetGeneratorAddress = database.addressStorage(keccak256(abi.encodePacked("contract", "AssetGenerator")));
+ bytes32 assetID = keccak256(abi.encodePacked(msg.sender, _tokenURI));
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", assetID))) == address(0));
+ DividendToken assetInstance = new DividendToken(_tokenURI, assetGeneratorAddress); // Gives this contract all new asset tokens
+ for (uint8 i = 0; i < _tokenHolders.length; i++) {
+ assetInstance.mint(_tokenHolders[i], _amount[i]);
+ }
+ assetInstance.finishMinting();
+ database.setAddress(keccak256(abi.encodePacked("assetManager", assetID)), msg.sender);
+ database.setAddress(keccak256(abi.encodePacked("tokenAddress", assetID)), address(assetInstance));
+ emit LogTradeableAssetCreated(assetID, address(assetInstance), msg.sender, _tokenURI);
+ return true;
+ }
+
+
+ // @notice reverts if user hasn't approved burner to burn platform token
+ modifier burnRequired {
+ ERC20Burner burner = ERC20Burner(database.addressStorage(keccak256(abi.encodePacked("contract", "ERC20Burner"))));
+ Erequire(burner.burn(msg.sender, database.uintStorage(keccak256(abi.encodePacked(msg.sig, address(this))))));
+ _;
+ }
+
+
+ event LogAssetCreated(bytes32 indexed _assetID, address indexed _tokenAddress, address indexed _assetManager, string _tokenURI);
+ event LogTradeableAssetCreated(bytes32 indexed _assetID, address indexed _tokenAddress, address indexed _assetManager, string _tokenURI);
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 | + + + + + + + + + + +9× + + + + + + + +7× +7× + + + + + + +9× +9× + + + + + + + + +18× +16× + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+contract PlatformFunds {
+
+ Database public database;
+
+ // @notice initialize database
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice owners must set the wallet to receive payments here before initiating crowdsale
+ // @dev will overwrite old wallet address
+ function setPlatformWallet(address _walletAddress)
+ external
+ onlyOwner {
+ database.setAddress(keccak256(abi.encodePacked("platformWallet")), _walletAddress);
+ emit LogPlatformWallet(_walletAddress);
+ }
+
+ // @notice
+ function setPlatformToken(address _tokenAddress)
+ external
+ onlyOwner {
+ database.setAddress(keccak256(abi.encodePacked("platformToken")), _tokenAddress);
+ emit LogPlatformToken(_tokenAddress);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ event LogPlatformWallet(address _platformWallet);
+ event LogPlatformToken(address _platformToken);
+
+
+
+
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+ import "../math/SafeMath.sol";
+ import "../database/Database.sol";
+ import "../interfaces/ERC20.sol";
+ import "../tokens/distribution/MintableDistribution.sol";
+
+
+
+ // @title A contract for investors to loan ERC20 tokens to assetManagers who require escrow
+ // @author Kyle Dewhurst, MyBit Foundation
+ // @notice AssetManager can lock his escrow in this contract and retrieve it if asset funding fails or successfully returns ROI
+ contract Staking {
+
+ Database public database;
+
+
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice AssetManager can request for a staker to lend tokens to cover escrow
+ function requestStaking(string _tokenURI, bytes32 _assetID, uint _amount, uint _sharePercentage)
+ external
+ returns (bool) {
+ bytes32 agreementHash = keccak256(abi.encodePacked(msg.sender, _assetID, _amount, _sharePercentage));
+ database.setBytes32(_assetID, agreementHash);
+ MintableDistribution mintableDistribution = new MintableDistribution(_tokenURI, address(this));
+ database.setAddress(keccak256(abi.encodePacked("stakingMint", _assetID)), address(mintableDistribution));
+ return true;
+ }
+
+ // @notice staker can purchase all of
+ function purchaseStake(bytes32 _assetID, address _requester, uint _amount, uint _sharePercentage)
+ external
+ returns (bool) {
+ bytes32 agreementHash = keccak256(abi.encodePacked(_requester, _assetID, _amount, _sharePercentage));
+ require (database.bytes32Storage(_assetID) == agreementHash);
+ ERC20 stakingToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ MintableDistribution distributionToken = MintableDistribution(database.addressStorage(keccak256(abi.encodePacked("stakingMint", _assetID))));
+ bytes32 finalAgreement = keccak256(abi.encodePacked(msg.sender, agreementHash));
+ database.setBytes32(_assetID, finalAgreement);
+ require(stakingToken.transfer(_requester, _amount));
+ require(distributionToken.mint(msg.sender, _amount));
+ require(distributionToken.finishMinting());
+ return true;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Don't accept null value for bytes32 parameter
+ //------------------------------------------------------------------------------------------------------------------
+ modifier noEmptyBytes(bytes32 _data) {
+ require(_data != bytes32(0));
+ _;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetExchange.sol | +100% | +55/55 | +92.5% | +37/40 | +100% | +15/15 | +100% | +66/66 | +|
| AssetGenerator.sol | +100% | +17/17 | +70% | +7/10 | +100% | +4/4 | +100% | +24/24 | +|
| PlatformFunds.sol | +100% | +4/4 | +100% | +2/2 | +100% | +4/4 | +100% | +7/7 | +|
| Staking.sol | +0% | +0/14 | +0% | +0/10 | +0% | +0/4 | +0% | +0/18 | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| access/ | +100% | +34/34 | +83.33% | +20/24 | +100% | +21/21 | +100% | +47/47 | +|
| crowdsale/ | +93.46% | +100/107 | +68.09% | +64/94 | +88.89% | +32/36 | +93.67% | +148/158 | +|
| database/ | +54.78% | +63/115 | +84.62% | +22/26 | +54.93% | +39/71 | +60.71% | +85/140 | +|
| ecosystem/ | +84.44% | +76/90 | +74.19% | +46/62 | +85.19% | +23/27 | +84.35% | +97/115 | +|
| interfaces/ | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| math/ | +100% | +12/12 | +100% | +8/8 | +100% | +5/5 | +100% | +12/12 | +|
| ownership/ | +32.47% | +25/77 | +37.5% | +9/24 | +41.38% | +12/29 | +32.71% | +35/107 | +|
| roles/ | +73.64% | +81/110 | +44.57% | +41/92 | +90.48% | +19/21 | +77.1% | +101/131 | +|
| test/ | +48.84% | +21/43 | +100% | +4/4 | +45.71% | +16/35 | +46.67% | +21/45 | +|
| tokens/distribution/ | +82.22% | +37/45 | +75% | +6/8 | +83.33% | +15/18 | +82% | +41/50 | +|
| tokens/erc20/ | +91.3% | +147/161 | +80.43% | +37/46 | +88.89% | +48/54 | +89.71% | +157/175 | +
| 1 +2 +3 +4 +5 +6 +7 | + + + + + + | pragma solidity ^0.4.24;
+
+// @notice Receive approval and then execute function
+interface ApproveAndCallFallBack {
+ function receiveApproval(address from, uint tokens, address token, bytes data) external;
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 | + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+interface BurnERC20 {
+
+ function burnFrom(address _tokenHolder, uint _amount) external returns (bool success);
+
+ function burn(uint _amount) external returns (bool success);
+
+ event LogBurn(address indexed _spender, uint256 _value);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 | + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+// @title An interface to interact with Burnable ERC20 tokens
+interface BurnableERC20 {
+
+ function allowance(address tokenOwner, address spender) external view returns (uint remaining);
+
+ function burnFrom(address _tokenHolder, uint _amount) external returns (bool success);
+
+ function burn(uint _amount) external returns (bool success);
+
+ function totalSupply() external view returns (uint256);
+
+ function balanceOf(address _who) external view returns (uint256);
+
+ function transfer(address _to, uint256 _value) external returns (bool);
+
+ function approve(address _spender, uint256 _value) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
+
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+
+ event LogBurn(address indexed _spender, uint256 _value);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+// Database interface
+interface DBInterface {
+
+ function setContractManager(address _contractManager)
+ external;
+
+ // --------------------Set Functions------------------------
+
+ function setAddress(bytes32 _key, address _value)
+ external;
+
+ function setUint(bytes32 _key, uint _value)
+ external;
+
+ function setString(bytes32 _key, string _value)
+ external;
+
+ function setBytes(bytes32 _key, bytes _value)
+ external;
+
+ function setBytes32(bytes32 _key, bytes32 _value)
+ external;
+
+ function setBool(bytes32 _key, bool _value)
+ external;
+
+ function setInt(bytes32 _key, int _value)
+ external;
+
+
+ // -------------- Deletion Functions ------------------
+
+ function deleteAddress(bytes32 _key)
+ external;
+
+ function deleteUint(bytes32 _key)
+ external;
+
+ function deleteString(bytes32 _key)
+ external;
+
+ function deleteBytes(bytes32 _key)
+ external;
+
+ function deleteBytes32(bytes32 _key)
+ external;
+
+ function deleteBool(bytes32 _key)
+ external;
+
+ function deleteInt(bytes32 _key)
+ external;
+
+ // ----------------Variable Getters---------------------
+
+ function uintStorage(bytes32 _key)
+ external
+ view
+ returns (uint);
+
+ function stringStorage(bytes32 _key)
+ external
+ view
+ returns (string);
+
+ function addressStorage(bytes32 _key)
+ external
+ view
+ returns (address);
+
+ function bytesStorage(bytes32 _key)
+ external
+ view
+ returns (bytes);
+
+ function bytes32Storage(bytes32 _key)
+ external
+ view
+ returns (bytes32);
+
+ function boolStorage(bytes32 _key)
+ external
+ view
+ returns (bool);
+
+ function intStorage(bytes32 _key)
+ external
+ view
+ returns (bool);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners receive their share when transferring tokens.
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+// TODO: Suicide function
+interface DivToken {
+
+ // @notice Transfer _amount tokens to address _to.
+ // @dev Sender must have enough tokens. Cannot send to 0x0.
+ // @param (address) _to = The address which will receive the tokens
+ // @param (uint) _amount = The amount of tokens to send
+ function transfer(address _to, uint _amount)
+ external
+ returns (bool success);
+
+ // @notice A 3rd party can transfer tokens if user approves them to do so
+ // @dev Transfer _amount of tokens if _from has allowed msg.sender to do so.
+ // @param (address) _from = The address who approved msg.sender to spend tokens
+ // @param (address) _to = The address who will receive the tokens
+ // @param (uint) _amount = The number of tokens to send
+ function transferFrom(address _from, address _to, uint _amount)
+ external
+ returns (bool success);
+
+ // @notice approves a 3rd party to transfer msg.sender's tokens on behalf of him/her
+ // @param (address) _spender = The address of who msg.sender approves to spend tokens on their behalf
+ // @param (uint) _amount = The upper limit of how many tokens can be spent
+ function approve(address _spender, uint _amount)
+ external
+ returns (bool success);
+
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ external
+ returns (bool success);
+
+ function withdraw()
+ external
+ returns (bool);
+
+ // @notice Updates incomeClaimed, sends all wei to the token holder
+ function collectOwedDividends()
+ external
+ returns (uint _amount);
+
+
+ // @notice Returns amount of tokens _spender is allowed to transfer or burn
+ function allowance(address _tokenHolder, address _spender)
+ external
+ view
+ returns (uint);
+
+ // @notice Returns the number of tokens in circulation
+ function totalSupply()
+ external
+ view
+ returns (uint tokenSupply);
+
+ // @notice Returns the token balance of user
+ function balanceOf(address _tokenHolder)
+ external
+ view
+ returns (uint balance);
+
+ // @notice Returns the URI of this token
+ function tokenURI()
+ external
+ view
+ returns (string);
+
+ function valuePerToken()
+ external
+ view
+ returns (uint);
+
+ function scalingFactor()
+ external
+ view
+ returns (uint);
+
+ // @notice Calculates how much value _user holds
+ function getAmountOwed(address _user)
+ external
+ view
+ returns (uint);
+
+ // @notice Calculates how much wei user is owed. (points + incomeClaimed) / 10**32
+ function getOwedDividends(address _user)
+ external
+ constant
+ returns (uint);
+
+ function assetIncome()
+ external
+ view
+ returns (uint);
+
+ function getERC20()
+ external
+ view
+ returns (address);
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(uint _block, address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 | + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+
+/**
+ * @title ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+interface ERC20 {
+ function totalSupply() external view returns (uint256);
+
+ function balanceOf(address _who) external view returns (uint256);
+
+ function allowance(address _owner, address _spender) external view returns (uint256);
+
+ function transfer(address _to, uint256 _value) external returns (bool);
+
+ function approve(address _spender, uint256 _value) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
+
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface ERC20DividendInterface{
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount) external returns (bool);
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting() external returns (bool);
+
+ function issueDividends(uint _amount) external;
+
+ // @dev Total number of tokens in existence
+ function totalSupply() external view returns (uint256);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 | + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface EtherDividendInterface{
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount) external returns (bool);
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting() external returns (bool);
+
+ function issueDividends() external payable;
+
+ // @dev Total number of tokens in existence
+ function totalSupply() external view returns (uint256);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 | + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+
+interface GovToken {
+
+ function totalSupply() external returns (uint);
+
+ function balanceOf(address _user) external returns (uint);
+
+ function unlockTokens() external returns (bool);
+
+ function lockTokens() external returns (bool);
+
+ function transfer(address _to, uint _amount) external returns (bool);
+
+ function transferFrom(address _from, address _to, uint _amount) external returns (bool);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 | + + + + + + + + | pragma solidity ^0.4.24;
+
+// @notice allows contract to call a basic withdraw() function taking no parameters on another contract
+interface PullPayment {
+
+ function withdraw() external returns(bool);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 | + + + + + + + + + | pragma solidity ^0.4.24;
+
+interface TokenFactoryInterface{
+
+ function createEtherDividend(string _tokenURI) external returns (address);
+
+ function createERC20Dividend(string _tokenURI, address _erc20Address) external returns (address);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ApproveAndCallFallback.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| BurnERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| BurnableERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| DBInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| DivToken.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| ERC20.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| ERC20DividendInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| EtherDividendInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| GovToken.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| PullPayment.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +|
| TokenFactoryInterface.sol | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +100% | +0/0 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 | + + + + + + + + + +149× +27× + +122× +122× +121× + + + + + + + +109× + + + + +497× +493× + + + + +474× +474× +473× + + + + + + + +1× + + + + | pragma solidity 0.4.24;
+
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+// @title SafeMath: overflow/underflow checks
+// @notice Math operations with safety checks that throw on error
+library SafeMath {
+
+ // @notice Multiplies two numbers, throws on overflow.
+ function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+ if (a == 0) {
+ return 0;
+ }
+ uint256 c = a * b;
+ assert(c / a == b);
+ return c;
+ }
+
+ // @notice Integer division of two numbers, truncating the quotient.
+ function div(uint256 a, uint256 b) internal pure returns (uint256) {
+ // assert(b > 0); // Solidity automatically throws 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 a / b;
+ }
+
+ // @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
+ function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+ assert(b <= a);
+ return a - b;
+ }
+
+ // @notice Adds two numbers, throws on overflow.
+ function add(uint256 a, uint256 b) internal pure returns (uint256) {
+ uint256 c = a + b;
+ assert(c >= a);
+ return c;
+ }
+
+ // @notice Returns fractional amount
+ function getFractionalAmount(uint256 _amount, uint256 _percentage)
+ internal
+ pure
+ returns (uint256) {
+ return div(mul(_amount, _percentage), 100);
+ }
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| SafeMath.sol | +100% | +12/12 | +100% | +8/8 | +100% | +5/5 | +100% | +12/12 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + +4× +4× +4× +4× +4× +4× +3× +3× +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + + + + + + + + + +4× +4× +4× +3× +3× + + + + + + + + + + + + + + + + + + +4× +4× + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+interface Burner { function burnEscrow(bytes32 _assetID) external returns (bool); }
+interface Escrow { function unlockEscrow(bytes32 _assetID) external returns (bool); }
+interface DB {
+ function addressStorage(bytes32 _key) external view returns (address);
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function setUint(bytes32 _key, uint _value) external;
+}
+interface TokenView {
+ function totalSupply() external view returns (uint);
+ function balanceOf(address _tokenHolder) external view returns (uint);
+}
+
+// @title A contract to manage the governance of assets on the platform
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice All token holders of an asset can vote here
+contract AssetGovernance {
+ using SafeMath for uint256;
+
+ DB public database;
+
+
+ constructor(address _database)
+ public {
+ database = DB(_database);
+ }
+
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...
+ // @dev ie sha3(_assetID) or sha3(_assetID, someAddress)
+ function voteForExecution(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash, uint _amountToLock)
+ external
+ validAsset(_assetID)
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", executionID));
+ bytes32 investorVotesID = keccak256(abi.encodePacked("investorVotes", executionID, msg.sender));
+ uint256 numVotes = database.uintStorage(numVotesID);
+ uint256 investorVotes = database.uintStorage(investorVotesID);
+ require(lockTokens(_assetID, msg.sender, _amountToLock));
+ database.setUint(numVotesID, numVotes.add(_amountToLock));
+ database.setUint(investorVotesID, investorVotes.add(_amountToLock));
+ return true;
+ }
+
+
+ // @notice unlock tokens, removing them from the vote
+ // @dev _executionID should be looked up in event logs. it is equal to sha3(_assetID, _methodID, _parameterHash)
+ function unlockToken(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash, uint _amountToUnlock)
+ external
+ validAsset(_assetID)
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 voteTotalID = keccak256(abi.encodePacked("voteTotal", executionID));
+ bytes32 investorVotesID = keccak256(abi.encodePacked("investorVotes", executionID));
+ uint investorVotes = database.uintStorage(investorVotesID);
+ uint totalVotes = database.uintStorage(voteTotalID);
+ require(investorVotes <= _amountToUnlock); // 1 vote = 1 token
+ database.setUint(voteTotalID, totalVotes.sub(_amountToUnlock));
+ database.setUint(investorVotesID, investorVotes.sub(_amountToUnlock));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Public Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Checks that 1/3 or more of token holders agreed on function call
+ function isConsensusReached(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ TokenView assetToken = TokenView(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", executionID));
+ uint256 numTokens = assetToken.totalSupply();
+ return database.uintStorage(numVotesID).mul(100).div(numTokens) >= 33;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Internal Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice lock asset tokens to be able to vote
+ // @dev keeps track of how many assetTokens this investor has locked (for GovernedToken checks)
+ function lockTokens(bytes32 _assetID, address _investor, uint _amount)
+ internal
+ returns (bool) {
+ TokenView assetToken = TokenView(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint numTokensLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)));
+ require(_amount <= assetToken.balanceOf(_investor).sub(numTokensLocked));
+ database.setUint(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)), numTokensLocked.add(_amount));
+ return true;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ /*
+ modifier hasConsensus(bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash) {
+ require(isConsensusReached(address(this), _assetID, _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ }
+ */
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/ERC20.sol';
+
+
+// @title A contract which allows for platform owners to come to consensus on important functionality
+// @notice Can hold any number of owners. Each getting 1 vote.
+// @dev An owner has already been initialized when database is deployed
+// @author Kyle Dewhurst, MyBit Foundation
+contract CollectiveOwned {
+ using SafeMath for uint256;
+
+ Database public database;
+
+ // @param (address) _database = the address of the platform database
+ // @param (uint) _baseQuorum = the percentage of owners needed to approve a function call
+ constructor(address _database, uint256 _baseQuorum)
+ public {
+ database = Database(_database);
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("setQuorumLevel(address, bytes4, uint256)")));
+ bytes32 functionID = keccak256(abi.encodePacked(address(this), methodID));
+ database.setUint(functionID, _baseQuorum); // the initial quorum level to set further quorum levels
+ }
+
+ // @notice any owner on the platform can call this function to add a new user if it has receieve quorum level of signatures
+ // @notice must
+ // @param (address) _newOwner the address of the new owner
+ function addOwner(address _newOwner)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_newOwner)))
+ onlyOwner {
+ uint numOwners = database.uintStorage(keccak256(abi.encodePacked("numberOfOwners")));
+ database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
+ database.setUint(keccak256(abi.encodePacked("numberOfOwners")), numOwners.add(1));
+ }
+
+ // @notice any owner can call this function to remove an owner if the the function receives quorum level of signatures
+ // @param (address) _owner = the owner to be removed from the group of owners
+ function removeOwner(address _owner)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_owner)))
+ onlyOwner {
+ database.deleteBool(keccak256(abi.encodePacked("owner", _owner)));
+ }
+
+ // @notice restricts a function, forcing it to require _quorumLevel of votes to be executed
+ function setQuorumLevel(address _contractAddress, bytes4 _methodID, uint256 _quorumLevel)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_contractAddress, _methodID, _quorumLevel)))
+ returns (bool) {
+ bytes32 functionID = keccak256(abi.encodePacked(_contractAddress, _methodID));
+ database.setUint(functionID, _quorumLevel);
+ return true;
+ }
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...ie sha3(true, 55)
+ function voteForExecution(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ external
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfSignatures", executionID));
+ uint256 numSignatures = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numSignatures.add(1));
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // View Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function isQuorumReached(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ uint256 quorumLevel = database.uintStorage(keccak256(abi.encodePacked(_contractAddress, _methodID)));
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ uint256 numOwners = database.uintStorage(keccak256(abi.encodePacked("numberOfOwners")));
+ // check that number of signatures are greater than required quorum
+ return database.uintStorage(numVotesID).mul(100).div(numOwners) >= quorumLevel;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(isQuorumReached(address(this), _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ database.deleteBool(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+ event LogOwnerChanged(address indexed _previousOwner, address indexed _newOwner);
+ event LogFunctionAuthorized(address indexed _owner, string indexed _functionName, bytes32 indexed _beneficiary, bytes32 _authHash);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | + + + + + + + + + + + + + + +4× + + + + + + + +3× +3× + + + + + + + +3× +3× + + + + +7× +6× + + + + + + + | pragma solidity 0.4.24;
+
+
+import '../database/Database.sol';
+
+// @title A contract which allows for the freezing of functionality within the platform.
+// @dev only valid with a single owned ownership model
+// @author Kyle Dewhurst, MyBit Foundation
+contract Pausible {
+
+ Database public database;
+
+ // @notice constructor: initialize database instance
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice This will pause all critical activity for the supplied address
+ // @param: The address of the contract which is to be paused\
+ function pause(address _contract)
+ onlyOwner
+ public {
+ database.setBool(keccak256(abi.encodePacked("paused", _contract)), true);
+ emit LogPaused(_contract, msg.sender);
+ }
+
+ // @notice This will unpause all critical activity for the supplied address
+ // @param: The address of the contract which is to be unpaused
+ function unpause(address _contract)
+ onlyOwner
+ public {
+ database.deleteBool(keccak256(abi.encodePacked("paused", _contract)));
+ emit LogUnpaused(_contract, msg.sender);
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner() {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ event LogPaused(address indexed _contract, address _owner);
+ event LogUnpaused(address indexed _contract, address _owner);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 | + + + + + + + + + + + + +2× + + + + + + +1× +1× +1× + + + + +2× +1× + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+// @title A contract for managing a single platform owner
+// @dev Single owned platforms store owner as an address
+// @author Kyle Dewhurst, MyBit Foundation
+contract SingleOwned {
+
+ Database public database;
+
+ // @notice constructor: initiate database instance
+ constructor(address _database) public {
+ database = Database(_database);
+ }
+
+ // @notice Transfer ownership to to a new owner
+ function changeOwner(address _newOwner)
+ public
+ onlyOwner {
+ database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
+ database.setBool(keccak256(abi.encodePacked("owner", msg.sender)), false);
+ emit OwnershipTransferred(msg.sender, _newOwner);
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner() {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+ event OwnershipTransferred(address indexed owner, address indexed pendingOwner);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/ERC20.sol';
+
+
+// @title A contract which allows for token holders to authorize particular functions to be called
+// @notice Token holders must lock their tokens against a particular function
+// @notice Token holders can unlock their tokens, removing their vote
+// @dev An owner has already been initialized when database is deployed
+// @author Kyle Dewhurst, MyBit Foundation
+contract TokenGovernance {
+ using SafeMath for uint256;
+
+ Database public database;
+
+ ERC20 public governanceToken;
+
+
+
+ // @dev methodID = bytes4(sha3("functionName(parameterType, parameterType)")
+ // @dev functionID = sha3(contractAddress, methodID)
+ // @dev numVotes is sha3(contractAddress, methodID, sha3(parameter, parameter)))
+ // @dev quorumLevel = percentage of tokens required to be locked for the execution of a function
+
+
+ // @notice initiator of the platform sets the initial functions quorum level
+ // @notice quorum level dictates the number of votes required for that function to be executed
+ constructor(address _database, uint256 _baseQuorum)
+ public {
+ governanceToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ database = Database(_database);
+ governanceToken = ERC20(governanceToken);
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("setQuorumLevel(address, bytes4, uint256)")));
+ bytes32 functionID = keccak256(abi.encodePacked(address(this), methodID));
+ database.setUint(functionID, _baseQuorum); // the initial quorum level to set further quorum levels
+ }
+
+ // @notice If restricted it will have to be called from address(this) using a voting proccess on signForFunctionCall
+ function setQuorumLevel(address _contractAddress, bytes4 _methodID, uint256 _quorumLevel)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_contractAddress, _methodID, _quorumLevel)))
+ returns (bool) {
+ bytes32 functionID = keccak256(abi.encodePacked(_contractAddress, _methodID));
+ database.setUint(functionID, _quorumLevel);
+ return true;
+ }
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...ie sha3(true, 55)
+ function voteForExecution(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash, uint256 _voteAmount)
+ external
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ require(lockTokens(_voteAmount, executionID));
+ uint256 numVotes = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numVotes.add(_voteAmount));
+ return true;
+ }
+
+
+ function unlockTokens(bytes32 _executionID)
+ external
+ returns (bool) {
+ bytes32 voteID = keccak256(abi.encodePacked("tokenVotesLocked", _executionID, msg.sender));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", _executionID));
+ uint256 amountLocked = database.uintStorage(voteID);
+ uint256 numVotes = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numVotes.sub(amountLocked));
+ governanceToken.transfer(msg.sender, amountLocked);
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function lockTokens(uint _amountToLock, bytes32 _executionID)
+ internal
+ returns (bool) {
+ bytes32 voteID = keccak256(abi.encodePacked("tokenVotesLocked", _executionID, msg.sender));
+ require(governanceToken.transferFrom(msg.sender, address(this), _amountToLock));
+ uint256 amountLocked = database.uintStorage(voteID);
+ database.setUint(voteID, amountLocked.add(_amountToLock));
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // View Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function isQuorumReached(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ uint256 quorumLevel = database.uintStorage(keccak256(abi.encodePacked(_contractAddress, _methodID)));
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ uint256 numTokens = governanceToken.totalSupply();
+ // check that number of signatures are greater than required quorum
+ return database.uintStorage(numVotesID).mul(100).div(numTokens) >= quorumLevel;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(isQuorumReached(address(this), _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ // remove votes from function call
+ database.deleteUint(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetGovernance.sol | +72% | +18/25 | +62.5% | +5/8 | +83.33% | +5/6 | +70.97% | +22/31 | +|
| CollectiveOwned.sol | +0% | +0/17 | +0% | +0/4 | +0% | +0/8 | +0% | +0/26 | +|
| Pausible.sol | +100% | +4/4 | +100% | +2/2 | +100% | +4/4 | +100% | +7/7 | +|
| SingleOwned.sol | +100% | +3/3 | +100% | +2/2 | +100% | +3/3 | +100% | +6/6 | +|
| TokenGovernance.sol | +0% | +0/28 | +0% | +0/8 | +0% | +0/8 | +0% | +0/37 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 | + + + + + + + + + + + + + + + + + + + + +3× + + + + + + + +4× +3× +3× +3× +3× +3× +3× +3× + + + + + + + + + +10× +9× +8× +8× +8× +8× +8× + +1× + + + +7× +7× +7× +7× +7× + +5× +5× +2× + +3× +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + +2× +2× +2× + + + + + + + + + | pragma solidity 0.4.24;
+
+ import "../math/SafeMath.sol";
+ import "../interfaces/DBInterface.sol";
+ import "../interfaces/DivToken.sol";
+ import "../interfaces/BurnableERC20.sol";
+
+ interface Governance { function isConsensusReached(address _thisContract, bytes4 _methodID, bytes32 _parameterHash) external view returns (bool); }
+
+ // @title A contract to hold escrow as collateral against assets
+ // @author Kyle Dewhurst, MyBit Foundation
+ // @notice AssetManager can lock his escrow in this contract and retrieve it if asset funding fails or successfully returns ROI
+ contract AssetManagerEscrow {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @dev assetID can be computed beforehand with sha3(msg.sender, _amountToRaise, _operatorID, _assetURI))
+ // @dev anybody can make the assetManager escrow if he leaves this contract with approval to transfer
+ function lockEscrow(bytes32 _assetID, uint _amount)
+ public
+ returns (bool) {
+ require(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))) == address(0));
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, msg.sender));
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("platformToken")));
+ Erequire(BurnableERC20(tokenAddress).transferFrom(msg.sender, address(this), _amount));
+ database.setUint(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID)), _amount);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", _assetID)), msg.sender);
+ emit LogEscrowLocked(_assetID, assetManagerEscrowID, msg.sender, _amount);
+ return true;
+ }
+
+
+ // @notice assetManager can unlock his escrow here once funding fails or asset returns sufficient ROI
+ // @dev asset must have fundingDeadline = 0 or have ROI > 25%
+ // @dev returns escrow according to ROI. 25% ROI returns 25% of escrow, 50% ROI returns 50% of escrow etc...
+ function unlockEscrow(bytes32 _assetID)
+ public
+ returns (bool) {
+ require(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))) == msg.sender);
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) < now);
+ BurnableERC20 burnToken = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, msg.sender));
+ uint escrowRedeemed = database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID)));
+ uint unlockAmount = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).sub(escrowRedeemed);
+ if(!database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)))){
+ //If we're past deadline but crowdsale did NOT finalize, release all escrow
+ Erequire(removeAssetManager(_assetID, assetManagerEscrowID));
+ }
+ else {
+ //Past the deadline with a successful funding. Only pay back based on ROI
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint roi = assetToken.assetIncome().mul(100).div(assetToken.totalSupply()); // Scaled up by 10^2 (approaches 100 as asset income increases)
+ uint roiCheckpoints = roi.div(25); // How many quarterly increments have been reached?
+ uint quarterEscrow = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).div(4);
+ require(roiCheckpoints <= 4 && roiCheckpoints > 0); // Can't unlock escrow past 100% ROI
+ // multiply the number of quarterly increments by a quarter of the escrow and subtract the escrow already redeemed.
+ unlockAmount = roiCheckpoints.mul(quarterEscrow).sub(escrowRedeemed);
+ require(unlockAmount > 0);
+ database.setUint(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID)), escrowRedeemed.add(unlockAmount));
+ }
+ Erequire(burnToken.transfer(msg.sender, unlockAmount));
+ return true;
+ }
+
+
+ // @notice investors can vote to call this function for the new assetManager to then call
+ // @dev new assetManager must approve this contract to transfer in and lock _ amount of platform tokens
+ function becomeAssetManager(bytes32 _assetID, address _oldAssetManager, uint256 _amount, bool _burn)
+ external
+ hasConsensus(_assetID, msg.sig, keccak256(abi.encodePacked(_assetID, _oldAssetManager, msg.sender, _amount, _burn)))
+ returns (bool) {
+ address currentAssetManager = database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID)));
+ require(currentAssetManager != msg.sender && currentAssetManager == _oldAssetManager);
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, _oldAssetManager));
+ uint oldEscrowRemaining = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).sub(database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID))));
+ BurnableERC20 token = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ require(removeAssetManager(_assetID, assetManagerEscrowID));
+ if (_burn) { require(token.burn(oldEscrowRemaining)); }
+ else { require(token.transfer(_oldAssetManager, oldEscrowRemaining)); }
+ require(lockEscrow(_assetID, _amount));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Internal Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ function removeAssetManager(bytes32 _assetID, bytes32 _assetManagerEscrowID)
+ internal
+ returns (bool) {
+ database.deleteAddress(keccak256(abi.encodePacked("assetManager", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerEscrow", _assetManagerEscrowID)));
+ database.deleteUint(keccak256(abi.encodePacked("escrowRedeemed", _assetManagerEscrowID)));
+ return true;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier hasConsensus(bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash) {
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", keccak256(abi.encodePacked(address(this), _assetID, _methodID, _parameterHash))));
+ uint256 numTokens = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)))).totalSupply();
+ Irequire(database.uintStorage(numVotesID).mul(100).div(numTokens) >= 33, 'Consensus not reached');
+ _;
+ }
+
+
+ event LogEscrowBurned(bytes32 indexed _assetID, address indexed _assetManager, uint _amountBurnt);
+ event LogEscrowLocked(bytes32 indexed _assetID, bytes32 indexed _assetManagerEscrowID, address indexed _assetManager, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 | + + + + + + + + + + + + + + + + + + + + + + + + + + +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× + +1× +1× +1× + +1× +1× + + +1× +1× + +1× + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× + +1× +1× + + + + + + + +1× +1× + +1× + + + + + +2× +2× +2× +2× + + + + + + + + | pragma solidity 0.4.24;
+
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../math/SafeMath.sol";
+
+interface DToken {
+ function withdraw() external returns (bool);
+ function getAmountOwed(address _user) external view returns (uint);
+ function balanceOf(address _tokenHolder) external view returns (uint);
+ function transfer(address _to, uint _amount) external returns (bool success);
+ function getERC20() external view returns (address);
+}
+
+// @title A dividend-token holding contract that locks tokens and retrieves dividends for assetManagers
+// @notice This contract receives newly minted tokens and retrieves Ether or ERC20 tokens received from the asset
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+contract AssetManagerFunds {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+
+ uint256 private transactionNumber;
+
+ // @notice constructor: initializes database
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @notice asset manager can withdraw his dividend fee from assets here
+ // @param : bytes32 _assetID = the ID of this asset on the platform
+ function withdraw(bytes32 _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))));
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ require(address(token) != address(0));
+ uint amountOwed;
+ uint balanceBefore;
+ if (token.getERC20() == address(0)){
+ balanceBefore = address(this).balance;
+ amountOwed = token.getAmountOwed(address(this));
+ require(amountOwed > 0);
+ uint balanceAfter = balanceBefore.add(amountOwed);
+ require(token.withdraw());
+ require(address(this).balance == balanceAfter);
+ msg.sender.transfer(amountOwed);
+ }
+ else {
+ amountOwed = token.getAmountOwed(address(this));
+ require(amountOwed > 0);
+ balanceBefore = token.balanceOf(address(this));
+ require(token.withdraw());
+ require(token.balanceOf(address(this)).sub(amountOwed) == balanceBefore);
+ token.transfer(msg.sender, amountOwed);
+ }
+ return true;
+ }
+
+ function retrieveAssetManagerTokens(bytes32[] _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ Erequire(_assetID.length <= 42);
+ uint[] memory payoutAmounts = new uint[](_assetID.length);
+ address[] memory tokenAddresses = new address[](_assetID.length);
+ uint8 numEntries;
+ for(uint8 i = 0; i < _assetID.length; i++){
+ Erequire(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID[i]))) );
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID[i]))));
+ Erequire(address(token) != address(0));
+ uint tokensOwed = token.getAmountOwed(address(this));
+ Erequire(tokensOwed > 0);
+ DToken fundingToken = DToken(token.getERC20());
+ uint balanceBefore = fundingToken.balanceOf(address(this));
+ uint8 tokenIndex = containsAddress(tokenAddresses, address(token));
+ Iif (tokenIndex < _assetID.length) { payoutAmounts[tokenIndex] = payoutAmounts[tokenIndex].add(tokensOwed); }
+ else {
+ tokenAddresses[numEntries] = address(fundingToken);
+ payoutAmounts[numEntries] = tokensOwed;
+ numEntries++;
+ }
+ Erequire(token.withdraw());
+ Erequire(fundingToken.balanceOf(address(this)).sub(tokensOwed) == balanceBefore);
+ }
+
+ for(i = 0; i < numEntries; i++){
+ Erequire(ERC20(tokenAddresses[i]).transfer(msg.sender, payoutAmounts[i]));
+ }
+ return true;
+ }
+
+
+ function retrieveAssetManagerETH(bytes32[] _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ Erequire(_assetID.length <= 93);
+ uint weiOwed;
+ for(uint8 i = 0; i < _assetID.length; i++){
+ Erequire(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID[i]))));
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID[i]))));
+ uint balanceBefore = address(this).balance;
+ uint amountOwed = token.getAmountOwed(address(this));
+ Erequire(amountOwed > 0);
+ uint balanceAfter = balanceBefore.add(amountOwed);
+ Erequire(token.withdraw());
+ Erequire(address(this).balance == balanceAfter);
+ weiOwed = weiOwed.add(amountOwed);
+ }
+ msg.sender.transfer(weiOwed);
+ return true;
+ }
+
+ // @notice returns the index if the address is in the list, otherwise returns list length + 1
+ function containsAddress(address[] _addressList, address _addr)
+ internal
+ pure
+ returns (uint8) {
+ for (uint8 i = 0; i < _addressList.length; i++){
+ Iif (_addressList[i] == _addr) return i;
+ }
+ return uint8(_addressList.length + 1);
+ }
+
+
+ // @notice prevents calls from re-entering contract
+ modifier nonReentrant() {
+ transactionNumber += 1;
+ uint256 localCounter = transactionNumber;
+ _;
+ Erequire(localCounter == transactionNumber);
+ }
+
+ function ()
+ payable
+ public {}
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 | + + + + + + + + + +8× + + + + + + + +10× +10× +10× +9× +9× +9× + + + + + + +3× +3× + + + + + + +3× +3× +2× +1× +1× +1× + + + + + + + +2× +2× + + + + + + + +3× +3× + + + + + + + + +14× +13× + + + + +5× +5× + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+
+contract Operators {
+
+ Database private database;
+
+ constructor(address _database) public {
+ database = Database(_database);
+ }
+
+ // @notice allows the platform owners to onboard a new operator.
+ // @notice operators will receive crowdfunding payments and are liable for producing/installing assets.
+ function registerOperator(address _operatorAddress, string _operatorURI)
+ external
+ onlyOwner {
+ Erequire(_operatorAddress != address(0));
+ bytes32 operatorID = keccak256(abi.encodePacked(_operatorURI));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", operatorID))) == address(0));
+ database.setAddress(keccak256(abi.encodePacked("operator", operatorID)), _operatorAddress);
+ database.setBytes32(keccak256(abi.encodePacked("operator", _operatorAddress)), operatorID);
+ emit LogOperatorRegistered(operatorID, _operatorURI);
+ }
+
+ // @notice owners can remove operators from the platform here
+ function removeOperator(bytes32 _operatorID)
+ external
+ onlyOwner {
+ database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
+ emit LogOperatorRemoved(_operatorID, msg.sender);
+ }
+
+
+ // @notice operator or owner can change the withdraw address of a registered operator
+ function changeOperatorAddress(bytes32 _operatorID, address _newAddress)
+ external {
+ address oldAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
+ require(oldAddress != address(0));
+ require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
+ database.setAddress(keccak256(abi.encodePacked("operator", _operatorID)), _newAddress);
+ emit LogOperatorAddressChanged(_operatorID, msg.sender, _newAddress);
+ }
+
+ // @notice operator can choose which ERC20 tokens he's willing to accept as payment
+ function acceptERC20Token(bytes32 _operatorID, address _tokenAddress, bool _accept)
+ external
+ onlyOperator(_operatorID)
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("acceptsToken", _operatorID, _tokenAddress)), _accept);
+ return true;
+ }
+
+ // @notice operator can choose whether or not to accept Ether
+ function acceptEther(bytes32 _operatorID, bool _accept)
+ external
+ onlyOperator(_operatorID)
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("acceptsEther", _operatorID)), _accept);
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice Sender must be the operator address for this operatorID
+ modifier onlyOperator(bytes32 _operatorID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) == msg.sender);
+ _;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+ event LogOperatorRegistered(bytes32 indexed _operatorID, string _operatorURI);
+ event LogOperatorRemoved(bytes32 indexed _operatorID, address _owner);
+ event LogOperatorAddressChanged(bytes32 indexed _operatorID, address _oldAddress, address _newAddress);
+ event LogOperatorAcceptsToken(bytes32 indexed _operatorID, address _tokenAddress);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetManagerEscrow.sol | +71.79% | +28/39 | +50% | +16/32 | +83.33% | +5/6 | +77.27% | +34/44 | +|
| AssetManagerFunds.sol | +68.42% | +39/57 | +31.25% | +15/48 | +85.71% | +6/7 | +68.75% | +44/64 | +|
| Operators.sol | +100% | +14/14 | +83.33% | +10/12 | +100% | +8/8 | +100% | +23/23 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 | + + + + +2× + + + + + | pragma solidity ^0.4.24;
+
+contract ApproveAndCallTest{
+ function receiveApproval(address from, uint tokens, address token, bytes data)
+ public {
+ emit LogApproval(from, tokens, token, data);
+ }
+
+ event LogApproval(address _from, uint _tokens, address _token, bytes _data);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 | + + + + + + + + + + + + + + + + + + + + + + + + +8× + + + + + + + + + + + + + +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + + + + + + +8× + + + + + + + + + + + + + +21× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+contract HashFunctions {
+
+ function toBytes(uint x)
+ external
+ pure
+ returns (bytes b) {
+ b = new bytes(32);
+ assembly { mstore(add(b, 32), x) }
+ }
+
+
+
+ function getMethodID(string _functionString)
+ public
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked(_functionString)));
+ }
+
+ function getAssetID(string _assetURI, uint _amountToRaise, bytes32 _operatorID)
+ public
+ view
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ }
+
+ function getOrderID(bytes _assetID, address _user, uint _amount, uint _price, bool _buyOrder)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_assetID, _user, _amount, _price, _buyOrder));
+ }
+
+ function getFunctionInitiatorHash(address _param1, address _param2, bytes32 _param3)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_param1, _param2, "destroy", _param3));
+ }
+
+ function uintHash(uint _param)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param));
+ }
+
+ function getStakingID(address _staker, uint256 _blockNumber, uint256 _amount)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_staker, _blockNumber, _amount));
+ }
+
+ function stringHash(string _name)
+ external
+ pure
+ returns (bytes32){
+ return keccak256(abi.encodePacked(_name));
+ }
+
+ function addressHash(address _param)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param));
+ }
+
+
+ function contractHash(string _name)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked("contract", _name));
+ }
+
+ function stringAddress(string _param, address _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringString(string _param, string _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return (keccak256(abi.encodePacked(_param, _paramTwo)));
+ }
+
+ function stringBytes(string _param, bytes32 _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringUint(string _param, uint _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringBytesAddress(string _param, bytes32 _paramTwo, address _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo, _paramThree));
+ }
+
+ function addressUintUint(address _param, uint _paramTwo, uint _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo, _paramThree));
+ }
+
+
+ function getAuthorizeHash(address _contractAddress, address _owner, string _fnName, bytes32 _recipient)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_contractAddress, _owner, _fnName, _recipient));
+ }
+
+ function uintUint(uint _paramOne, uint _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_paramOne, _paramTwo));
+ }
+
+
+ function uintUintUint(uint _paramOne, uint _paramTwo, uint _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_paramOne, _paramTwo, _paramThree));
+ }
+
+ function currentTime()
+ external
+ view
+ returns (uint) {
+ return now;
+ }
+
+ function nullBytes()
+ external
+ pure
+ returns (bytes32) {
+ return bytes32(0);
+ }
+
+ function nullAddress()
+ external
+ pure
+ returns (address) {
+ return address(0);
+ }
+
+function ()
+public {
+ revert();
+}
+
+
+
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 | + + + + + + + + +3× + + + +1× + + + +2× + + + +2× + + + +1× + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+
+contract SafeMathWrapper {
+ using SafeMath for uint;
+ using SafeMath for bytes;
+
+ function multiply(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.mul(b);
+ }
+
+ function divide(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.div(b);
+ }
+
+ function subtract(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.sub(b);
+ }
+
+ function addto(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.add(b);
+ }
+
+ function fraction(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.getFractionalAmount(b);
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 | + + + + + + + + + + + + + +1× +1× + + + + +4× + + + + + +2× +2× +2× +1× + + + + + + +1× + + + + | pragma solidity 0.4.24;
+
+import '../access/ERC20Burner.sol';
+import '../database/Database.sol';
+
+contract TestBurner {
+
+ ERC20Burner public burner;
+ Database public database;
+
+ uint public amountBurnt;
+
+ constructor(address _database, address _burner)
+ public {
+ burner = ERC20Burner(_burner);
+ database = Database(_database);
+ }
+
+ function burnTokensManualFee(uint _amount)
+ external {
+ require(burner.burn(msg.sender, _amount));
+ }
+
+ // Must set fee in ERC20Burner first
+ function burnTokens()
+ external {
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("burnTokens()")));
+ uint amountToBurn = database.uintStorage(keccak256(abi.encodePacked(methodID, address(this))));
+ require(burner.burn(msg.sender, amountToBurn));
+ amountBurnt += amountToBurn;
+ }
+
+ function getMethodID()
+ external
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked("burnTokens()")));
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + | pragma solidity ^0.4.24;
+
+contract WithdrawTest{
+
+ mapping(address => uint) public balances;
+
+ function withdraw()
+ external
+ returns (bool){
+ emit LogWithdraw(msg.sender, balances[msg.sender]);
+ uint amount = balances[msg.sender];
+ balances[msg.sender] = 0;
+ msg.sender.transfer(amount);
+ return true;
+ }
+
+ function deposit(address _receiver)
+ payable
+ external{
+ emit LogDeposit(_receiver, msg.value);
+ balances[_receiver] += msg.value;
+ }
+
+ event LogDeposit(address _receiver, uint _amount);
+ event LogWithdraw(address _receiver, uint _amount);
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ApproveAndCallTest.sol | +100% | +1/1 | +100% | +0/0 | +100% | +1/1 | +100% | +1/1 | +|
| HashFunctions.sol | +21.74% | +5/23 | +100% | +0/0 | +21.74% | +5/23 | +20.83% | +5/24 | +|
| SafeMathWrapper.sol | +100% | +5/5 | +100% | +0/0 | +100% | +5/5 | +100% | +5/5 | +|
| TestBurner.sol | +100% | +8/8 | +100% | +4/4 | +100% | +4/4 | +100% | +8/8 | +|
| WithdrawTest.sol | +33.33% | +2/6 | +100% | +0/0 | +50% | +1/2 | +28.57% | +2/7 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 | + + + + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +5× + +1× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import '../../interfaces/PullPayment.sol';
+
+// @title A contract made to equally distribute payments amongs a list of beneficiaries
+// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+// @notice This contract allows someone to leave ETH for a beneficiary
+// @dev assumes each beneficiary receives equal amount
+contract EqualDistribution {
+ using SafeMath for uint;
+
+ address[] public beneficiaries; // List of chosen beneficiaries
+
+ uint public totalReleased; // Total WEI so far released to beneficiaries
+
+ mapping (address => uint) public amountRedeemed; // Amount of WEI this address has already withdrawn from contract
+
+
+ // @notice constructor. Sets the beneficiaries and where the income to be distributed is coming from
+ // @param (address) _beneficiary = The ETH address of who is to receive the income. Could be a distribution contract.
+ constructor(address[] _beneficiaries)
+ public{
+ Erequire(_beneficiaries.length < 200);
+ beneficiaries = _beneficiaries;
+ }
+
+ // @notice allows beneficiaries to withdraw from contracts at different locations to be re-distributed here
+ // @dev can call withdraw() on any address if there are no parameters required. Fallback function will be triggered
+ // @param (address) _contractAddress = The address to call withdraw() on.
+ function getFunds(address _contractAddress)
+ external
+ returns (bool) {
+ PullPayment(_contractAddress).withdraw();
+ return true;
+ }
+
+ // @notice beneficiaries can withdraw their share of the income here
+ function withdraw()
+ external
+ returns (bool) {
+ uint amount = ((address(this).balance.add(totalReleased)).div(beneficiaries.length)).sub(amountRedeemed[msg.sender]);
+ amountRedeemed[msg.sender] = amountRedeemed[msg.sender].add(amount);
+ totalReleased = totalReleased.add(amount);
+ msg.sender.transfer(amount);
+ emit LogWithdraw(msg.sender, amount);
+ return true;
+ }
+
+ // @notice fallback function. Accepts Ether and updates income balance
+ function ()
+ public
+ payable {
+ emit LogPayment(msg.sender, msg.value);
+ }
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Constants
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice check if the address is one of the beneficiaries
+ function isBeneficiary(address _beneficiary)
+ public
+ view
+ returns (bool) {
+ for (uint i = 0; i < beneficiaries.length; i++){
+ if (beneficiaries[i] == _beneficiary) { return true; }
+ }
+ return false;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogPayment(address _sender, uint _amount);
+ event LogWithdraw(address _beneficiary, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | + + + + + + + + + + + + + + + +2× +2× +2× +2× +6× +6× + +2× + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import './StandardDistribution.sol';
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract FixedDistribution is StandardDistribution {
+ using SafeMath for uint;
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ public {
+ Erequire(_tokenHolders.length < 200 && _tokenHolders.length == _amount.length);
+ uint _totalSupply;
+ tokenURI = _tokenURI;
+ for (uint8 i = 0; i < _tokenHolders.length; i++) {
+ _totalSupply = _totalSupply.add(_amount[i]);
+ balances[_tokenHolders[i]] = balances[_tokenHolders[i]].add(_amount[i]);
+ }
+ supply = _totalSupply;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 | + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + +2× +2× +2× +2× + + + + + + + + +1× +1× +1× + + + + + + + + + +4× +3× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import './StandardDistribution.sol';
+
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBitFoundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract MintableDistribution is StandardDistribution{
+ using SafeMath for uint;
+
+ bool public mintingFinished = false;
+ address public minter;
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _minter)
+ public {
+ tokenURI = _tokenURI; // Set the id for reference
+ minter = _minter;
+ }
+
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount)
+ public
+ canMint
+ returns (bool) {
+ supply = supply.add(_amount);
+ balances[_to] = balances[_to].add(_amount);
+ emit Mint(_to, _amount);
+ return true;
+ }
+
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting()
+ public
+ canMint
+ returns (bool) {
+ mintingFinished = true;
+ emit MintFinished();
+ return true;
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+
+ // @notice modifier: Requires that minting hasn't finished
+ modifier canMint() {
+ require(!mintingFinished && msg.sender == minter);
+ _;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+
+ event Mint(address indexed to, uint256 amount);
+ event MintFinished();
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +4× +4× +4× +4× + + + + + + + + + + + + + + + + +1× +1× +1× + + + + + + +2× +2× +2× + + + + + + + + + + + +5× +5× + + + + + + + +1× + + + +1× + + + +7× + + + + + + + + + +4× +4× +4× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import '../../interfaces/PullPayment.sol';
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBitFoundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract StandardDistribution{
+ using SafeMath for uint;
+
+
+ uint public supply;
+ mapping (address => uint) internal balances;
+
+ string public tokenURI; // A reference to a URI containing further token information
+
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+ uint public assetIncome;
+ uint public valuePerToken;
+
+ mapping (address => uint) public claimableIncome;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice Updates claimableIncome, sends all wei to the token holder
+ function withdraw()
+ public
+ updateclaimableIncome(msg.sender)
+ returns (uint _amount) {
+ _amount = claimableIncome[msg.sender].div(scalingFactor);
+ delete claimableIncome[msg.sender];
+ msg.sender.transfer(_amount);
+ emit LogIncomeCollected(now, msg.sender, _amount);
+ }
+/*
+ // @notice allows beneficiaries to withdraw from contracts at different locations to be re-distributed here
+ // @dev can call withdraw() on any address if there are no parameters required. Fallback function will be triggered
+ // @param (address) _contractAddress = The address to call withdraw() on.
+ function getFunds(address _contractAddress)
+ external
+ returns (bool) {
+ PullPayment(_contractAddress).withdraw();
+ return true;
+ }
+
+*/
+ function issueDividends()
+ payable
+ public {
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(msg.value);
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+ // Fallback function: Accepts Ether and updates ledger (issues dividends)
+ function ()
+ payable
+ public {
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(msg.value);
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // View Functions
+ // ------------------------------------------------------------------------------------------------
+
+ // @notice Calculates how much value _user holds
+ function getTokenValue(address _user)
+ public
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_user]);
+ return valuePerTokenDifference.mul(balances[_user]);
+ }
+
+ // @notice Calculates how much wei user is owed. (new income + claimableIncome) / 10**32
+ function getUnclaimedAmount(address _user)
+ public
+ view
+ returns (uint) {
+ return (getTokenValue(_user).add(claimableIncome[_user]).div(scalingFactor));
+ }
+
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+ // Updates the amount owed to user while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateclaimableIncome(address _user) {
+ claimableIncome[_user] = claimableIncome[_user].add(getTokenValue(_user));
+ previousValuePerToken[_user] = valuePerToken;
+ _;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(uint _block, address _address, uint _amount);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| EqualDistribution.sol | +42.86% | +6/14 | +75% | +3/4 | +40% | +2/5 | +35.71% | +5/14 | +|
| FixedDistribution.sol | +100% | +6/6 | +50% | +1/2 | +100% | +1/1 | +100% | +7/7 | +|
| MintableDistribution.sol | +100% | +10/10 | +100% | +2/2 | +100% | +4/4 | +100% | +11/11 | +|
| StandardDistribution.sol | +100% | +15/15 | +100% | +0/0 | +100% | +8/8 | +100% | +18/18 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 | + + + + + + + + + + + + + + + + + + + + + + + + +12× +12× +12× +12× + + + + + + + + + + + +204× +203× +201× +201× +201× +201× + + + + + + + + + + + + + + +156× +156× +156× + + + + + + + + + + + +17× +16× +15× +15× +14× +14× + + + + + + + + + + + + + + +1× + +1× +1× + + + + + + + + + + + + + + +2× +2× +1× + + +1× + +2× +2× + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + + + + + + +40× +40× +39× +39× +39× +39× + + + + + + + + +2× + + + + + + + + +199× + + + + + + + + + + + + + +5× + + + + | pragma solidity 0.4.24;
+
+import "./StandardToken.sol";
+import "../../interfaces/BurnableERC20.sol";
+import "../../math/SafeMath.sol";
+
+// @title ERC20 token contract with burning capabilities
+// @notice Standard ERC20 contract with a deflationary supply.
+contract BurnableToken is BurnableERC20 {
+ using SafeMath for uint256;
+
+ string public tokenURI;
+
+ mapping(address => uint256) internal balances;
+
+ mapping (address => mapping (address => uint256)) internal allowed;
+
+ uint256 internal supply;
+
+
+ // @notice constructor: initialized
+ // @param (string) _tokenURI = The URI where information about this token can be found
+ // @param (uint) _totalSupply = The initial supply of the token
+ constructor(string _tokenURI, uint _totalSupply)
+ public {
+ supply = _totalSupply; // Update total supply
+ tokenURI = _tokenURI; // Set the id for reference
+ balances[msg.sender] = _totalSupply;
+ emit Transfer(address(0), msg.sender, _totalSupply); // Transfer event indicating token creation
+ }
+
+
+ /**
+ * @dev Transfer token for a specified address
+ * @param _to The address to transfer to.
+ * @param _value The amount to be transferred.
+ */
+ function transfer(address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_value <= balances[msg.sender]);
+ require(_to != address(0));
+ balances[msg.sender] = balances[msg.sender].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ emit Transfer(msg.sender, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+ * Beware that changing an allowance with this method brings the risk that someone may use both the old
+ * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ * @param _spender The address which will spend the funds.
+ * @param _value The amount of tokens to be spent.
+ */
+ function approve(address _spender, uint256 _value)
+ public
+ returns (bool) {
+ allowed[msg.sender][_spender] = _value;
+ emit Approval(msg.sender, _spender, _value);
+ return true;
+ }
+
+ /**
+ * @dev Transfer tokens from one address to another
+ * @param _from address The address which you want to send tokens from
+ * @param _to address The address which you want to transfer to
+ * @param _value uint256 the amount of tokens to be transferred
+ */
+ function transferFrom(address _from, address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_to != address(0)); // use burn instead
+ balances[_from] = balances[_from].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+ emit Transfer(_from, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Increase the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To increment
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _addedValue The amount of tokens to increase the allowance by.
+ */
+ function increaseApproval(address _spender, uint256 _addedValue)
+ public
+ returns (bool) {
+ allowed[msg.sender][_spender] = (
+ allowed[msg.sender][_spender].add(_addedValue));
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+ /**
+ * @dev Decrease the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To decrement
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _subtractedValue The amount of tokens to decrease the allowance by.
+ */
+ function decreaseApproval(address _spender, uint256 _subtractedValue)
+ public
+ returns (bool) {
+ uint256 oldValue = allowed[msg.sender][_spender];
+ if (_subtractedValue >= oldValue) {
+ allowed[msg.sender][_spender] = 0;
+ }
+ else {
+ allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+ }
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+
+
+ // ------------------------------------------------------------------------
+ // Removes senders tokens from supply.
+ // Lowers investor balance and totalSupply by _amount
+ // ------------------------------------------------------------------------
+ function burn(uint _amount)
+ public
+ returns (bool success) {
+ balances[msg.sender] = balances[msg.sender].sub(_amount);
+ supply = supply.sub(_amount);
+ emit LogBurn(msg.sender, _amount);
+ emit Transfer(msg.sender, address(0), _amount);
+ return true;
+ }
+
+ // ------------------------------------------------------------------------
+ // An approved sender can burn _amount tokens of investor _from
+ // Lowers investor balance and supply by _amount
+ // ------------------------------------------------------------------------
+ function burnFrom(address _from, uint _amount)
+ public
+ returns (bool success) {
+ balances[_from] = balances[_from].sub(_amount); // Subtract from the targeted balance
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); // Subtract from the sender's allowance
+ supply = supply.sub(_amount); // Update supply
+ emit LogBurn(_from, _amount);
+ emit Transfer(_from, address(0), _amount);
+ return true;
+ }
+
+
+
+ /**
+ * @dev Total number of tokens in existence
+ */
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ /**
+ * @dev Gets the balance of the specified address.
+ * @param _owner The address to query the the balance of.
+ * @return An uint256 representing the amount owned by the passed address.
+ */
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+
+ /**
+ * @dev Function to check the amount of tokens that an owner allowed to a spender.
+ * @param _owner address The address which owns the funds.
+ * @param _spender address The address which will spend the funds.
+ * @return A uint256 specifying the amount of tokens still available for the spender.
+ */
+ function allowance(address _owner, address _spender)
+ public
+ view
+ returns (uint256) {
+ return allowed[_owner][_spender];
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +4× +3× +1× + + + + + + + + + + + + +6× +5× +3× + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + +10× +10× +10× +10× +10× + + + + + + + +7× +7× +7× +7× + + + + + + + + + + + + + + +4× +4× +4× + + + + + + + + + + + + +36× +36× + + + + + + + +4× + + + + + + + + + +32× +32× +32× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import './MintableToken.sol';
+import '../../math/SafeMath.sol';
+import '../../interfaces/ApproveAndCallFallback.sol';
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners receive their share when transferring tokens.
+// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract DividendToken is MintableToken {
+ using SafeMath for uint;
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+ uint public valuePerToken;
+ uint public assetIncome;
+
+ mapping (address => uint) public incomeOwed;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _owner)
+ public
+ MintableToken(_tokenURI, _owner){}
+
+ // @notice Transfer _amount tokens to address _to.
+ // @dev Sender must have enough tokens. Cannot send to 0x0.
+ // @param (address) _to = The address which will receive the tokens
+ // @param (uint) _amount = The amount of tokens to send
+ function transfer(address _to, uint _amount)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice A 3rd party can transfer tokens if investor approves them to do so
+ // @dev Transfer _amount of tokens if _from has allowed msg.sender to do so.
+ // @param (address) _from = The address who approved msg.sender to spend tokens
+ // @param (address) _to = The address who will receive the tokens
+ // @param (uint) _amount = The number of tokens to send
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ updateIncomeClaimed(_from)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_spender)
+ returns (bool success) {
+ allowed[msg.sender][_spender] = _amount;
+ emit Approval(msg.sender, _spender, _amount);
+ ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _data);
+ return true;
+ }
+
+ // @notice token holders can withdraw income here
+ function withdraw()
+ public
+ updateIncomeClaimed(msg.sender)
+ returns (bool) {
+ uint amount = incomeOwed[msg.sender].div(scalingFactor);
+ delete incomeOwed[msg.sender];
+ emit LogIncomeCollected(msg.sender, amount);
+ msg.sender.transfer(amount);
+ return true;
+ }
+
+ // @notice assets can send their income here to be collected by investors
+ function issueDividends()
+ payable
+ public
+ returns (bool) {
+ assetIncome = assetIncome.add(msg.value);
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ emit LogIncomeReceived(msg.sender, msg.value);
+ return true;
+ }
+
+ // @notice returns null address to specify this token accepts only Ether payments
+ function getERC20()
+ external
+ pure
+ returns(address){
+ return address(0);
+ }
+
+ // Fallback function: receives Ether and updates income ledger
+ function ()
+ payable
+ public {
+ assetIncome = assetIncome.add(msg.value);
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+
+ // ------------------------------------------------------------------------
+ // View functions
+ // ------------------------------------------------------------------------
+
+ // @notice Calculates how much more income is owed to investor since last calculation
+ function collectLatestPayments(address _investor)
+ private
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_investor]);
+ return valuePerTokenDifference.mul(balances[_investor]);
+ }
+
+ // @notice Calculates how much wei investor is owed. (points + incomeOwed) / 10**32
+ function getAmountOwed(address _investor)
+ public
+ view
+ returns (uint) {
+ return (collectLatestPayments(_investor).add(incomeOwed[_investor]).div(scalingFactor));
+ }
+
+ // ------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------
+
+ // Updates the amount owed to investor while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateIncomeClaimed(address _investor) {
+ incomeOwed[_investor] = incomeOwed[_investor].add(collectLatestPayments(_investor));
+ previousValuePerToken[_investor] = valuePerToken;
+ _;
+ }
+
+
+
+
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +5× + + + + + + + + +3× +2× +1× + + + + + + + + +3× +2× +1× + + + + + + + + + + + +1× +1× +1× +1× + + + + + +6× +5× +5× +5× +5× +5× + + + + + + + +10× +10× +10× +10× +10× +10× + + + + + + + +2× +2× +2× +2× + +1× +1× + +2× + + + + + + + + + + + + +28× +28× + + + + + + + +4× + + + + + + +2× + + + + + + + + + +24× +24× +24× + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+import './MintableToken.sol';
+import '../../math/SafeMath.sol';
+import '../../interfaces/ERC20.sol';
+import '../../interfaces/ApproveAndCallFallback.sol';
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive ERC20 tokens as payments and token owners receive their share when transferring tokens.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract DividendTokenERC20 is MintableToken {
+ using SafeMath for uint;
+
+ ERC20 public erc20;
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+
+ uint public assetIncome;
+ uint public assetIncomeIssued;
+ uint public valuePerToken;
+
+
+ mapping (address => uint) public incomeClaimed;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _owner, address _erc20Address)
+ public MintableToken(_tokenURI, _owner){
+ erc20 = ERC20(_erc20Address); //Set the address of the ERC20 token that will be issued as dividends
+ }
+
+
+ function transfer(address _to, uint _amount)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ updateIncomeClaimed(_from)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_spender)
+ returns (bool success) {
+ allowed[msg.sender][_spender] = _amount;
+ emit Approval(msg.sender, _spender, _amount);
+ ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _data);
+ return true;
+ }
+
+ function issueDividends(uint _amount)
+ public
+ returns (bool){
+ require(_amount > 0);
+ Erequire(erc20.transferFrom(msg.sender, address(this), _amount));
+ valuePerToken = valuePerToken.add(_amount.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(_amount);
+ emit LogIncomeReceived(msg.sender, _amount);
+ return true;
+ }
+
+ // @notice Updates incomeClaimed, sends all wei to the token holder
+ function withdraw()
+ public
+ updateIncomeClaimed(msg.sender)
+ returns (bool) {
+ uint amount = incomeClaimed[msg.sender].div(scalingFactor);
+ delete incomeClaimed[msg.sender];
+ assetIncomeIssued = assetIncomeIssued.add(amount);
+ Erequire(erc20.transfer(msg.sender, amount));
+ emit LogIncomeCollected(msg.sender, amount);
+ return true;
+ }
+
+ //In case a investor transferred a token directly to this contract
+ //anyone can run this function to clean up the balances
+ //and distribute the difference to token holders
+ function checkForTransfers()
+ external {
+ uint bookBalance = assetIncome.sub(assetIncomeIssued);
+ uint actualBalance = erc20.balanceOf(address(this));
+ uint diffBalance = actualBalance.sub(bookBalance);
+ if(diffBalance > 0){
+ //Update value per token
+ valuePerToken = valuePerToken.add(diffBalance.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(diffBalance);
+ }
+ emit LogCheckBalance(diffBalance);
+ }
+
+
+ // ------------------------------------------------------------------------
+ // View functions
+ // ------------------------------------------------------------------------
+
+ // @notice Calculates how much value _investor holds
+ function collectLatestPayments(address _investor)
+ public
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_investor]);
+ return valuePerTokenDifference.mul(balances[_investor]);
+ }
+
+ // @notice Calculates how much wei investor is owed. (points + incomeClaimed) / 10**32
+ function getAmountOwed(address _investor)
+ public
+ view
+ returns (uint) {
+ return (collectLatestPayments(_investor).add(incomeClaimed[_investor]).div(scalingFactor));
+ }
+
+ function getERC20()
+ external
+ view
+ returns(address){
+ return address(erc20);
+ }
+
+ // ------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------
+
+ // Updates the amount owed to investor while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateIncomeClaimed(address _investor) {
+ incomeClaimed[_investor] = incomeClaimed[_investor].add(collectLatestPayments(_investor));
+ previousValuePerToken[_investor] = valuePerToken;
+ _;
+ }
+
+ // Fallback function:
+ // Only works with ERC223
+ // Can't currently detect which token
+ /*
+ function tokenFallback(address _from, uint _value, bytes _data)
+ public {
+ valuePerToken = valuePerToken.add(_value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(_value);
+ emit LogIncomeReceived(_from, _value);
+ }
+ */
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogCheckBalance(uint _difference);
+ event LogIncomeCollected(address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + +1× + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + | pragma solidity 0.4.24;
+
+import "./DividendToken.sol";
+import "../../math/SafeMath.sol";
+
+
+// @notice give GovernedToken access to view uint and bytes32 storage
+interface DBAccess {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+}
+
+// @title A Dividend token that has governance features .
+// @notice This token contract can receive ERC20 tokens as payments and token owners can lock tokens while submitting votes
+// @dev Dividend tokens aren't actually locked, but restricted from transferring to avoid locking contravt having to distribute dividends.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+contract GovernedToken is DividendToken {
+ using SafeMath for uint;
+
+ DBAccess public database;
+
+
+ // @notice constructor: initialized
+ constructor(address _database, string _tokenURI, address _owner)
+ public
+ DividendToken(_tokenURI, _owner){
+ database = DBAccess(_database);
+ }
+
+ // @notice Standard DividendToke transfer function, which checks for locked tokens before sending
+ function transfer(address _to, uint _amount)
+ public
+ returns (bool success) {
+ Irequire(_amount <= getAmountAvailable(msg.sender));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice Standard DividendToke transferFrom function, which checks for locked tokens before sending
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(_from));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice returns the amount of tokens _investor has locked for this asset
+ function getAmountAvailable(address _investor)
+ public
+ view
+ returns (uint) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", address(this))));
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", assetID, _investor)));
+ uint balance = balances[_investor];
+ uint available = balance.sub(amountLocked);
+ return available;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "./DividendTokenERC20.sol";
+import "../../math/SafeMath.sol";
+
+// @notice give GovernedToken access to view uint and bytes32 storage
+interface DBAccess {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+}
+
+// @title A Dividend token that has governance features and receives ERC20 tokens as payment
+// @notice This token contract can receive ERC20 tokens as payments and token owners can lock tokens while submitting votes
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @dev Dividend tokens aren't actually locked, but restricted from transferring to avoid locking contravt having to distribute dividends.
+contract GovernedTokenERC20 is DividendTokenERC20{
+ DBAccess public database;
+
+
+ // @notice constructor: initializes database and DividendTokenERC20
+ // @param (address) _database = the address of the platform database
+ // @param (string) _tokenURI = The URI where details of the token (asse) can be found
+ // @param (address) _owner = The minting authority for this token
+ // @param (address) _erc20Address = The address of the erc20 token to be sent for dividends
+ constructor(address _database, string _tokenURI, address _owner, address _erc20Address)
+ public
+ DividendTokenERC20(_tokenURI, _owner, _erc20Address){
+ database = DBAccess(_database);
+ }
+
+ // @notice Standard DividendToke transfer function, which checks for locked tokens before sending
+ function transfer(address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(msg.sender));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice Standard DividendToke transferFrom function, which checks for locked tokens before sending
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(_from));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice returns the amount of tokens _investor has locked for this asset
+ function getAmountAvailable(address _investor)
+ public
+ view
+ returns (uint) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", address(this))));
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", assetID, _investor)));
+ uint balance = balances[_investor];
+ uint available = balance.sub(amountLocked);
+ return available;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | + + + + + + + + + + + + + + + + + + + +17× +17× +17× + + + + + + + + + + +43× +43× +43× +43× +43× + + + + + + + +7× +7× +7× + + + + + + +2× + + + + +51× +50× + + + + + + | pragma solidity 0.4.24;
+
+import "./StandardToken.sol";
+
+
+/**
+ * @title Mintable token
+ * @dev Simple ERC20 Token example, with mintable token creation
+ * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
+ */
+contract MintableToken is StandardToken {
+
+ bool public mintingFinished;
+ address internal minter;
+ string internal tokenURI; // A reference to a URI containing further token information
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _minter)
+ public {
+ tokenURI = _tokenURI; // Set the id for reference
+ minter = _minter;
+ supply = 0;
+ }
+
+
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount)
+ public
+ canMint
+ returns (bool) {
+ supply = supply.add(_amount);
+ balances[_to] = balances[_to].add(_amount);
+ emit Mint(_to, _amount);
+ emit Transfer(address(0), _to, _amount);
+ return true;
+ }
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting()
+ public
+ canMint
+ returns (bool) {
+ mintingFinished = true;
+ emit MintFinished();
+ return true;
+ }
+
+ function getTokenURI()
+ external
+ view
+ returns (string) {
+ return tokenURI;
+ }
+
+ // @notice modifier: Requires that minting hasn't finished
+ modifier canMint() {
+ require(!mintingFinished && msg.sender == minter);
+ _;
+ }
+
+ event Mint(address indexed to, uint256 amount);
+ event MintFinished();
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +17× + + + + + + + + +5× +3× +2× +2× +2× +2× + + + + + + + + + + + + +11× +11× +11× + + + + + + + + + + + +7× +6× +5× +4× +4× +4× +4× +4× + + + + + + + + + + + + + + + + + + +1× + +1× +1× + + + + + + + + + + + + + + +2× +2× +1× + + +1× + +2× +2× + + + + + + + +36× + + + + + + + + +55× + + + + + | pragma solidity 0.4.24;
+
+import "../../interfaces/ERC20.sol";
+import "../../math/SafeMath.sol";
+
+
+/**
+ * @title Standard ERC20 token
+ *
+ * @dev Implementation of the basic standard token.
+ * https://github.com/ethereum/EIPs/issues/20
+ * Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
+ */
+contract StandardToken is ERC20 {
+ using SafeMath for uint256;
+
+ mapping(address => uint256) internal balances;
+
+ mapping (address => mapping (address => uint256)) internal allowed;
+
+ uint256 internal supply;
+
+
+ /**
+ * @dev Function to check the amount of tokens that an owner allowed to a spender.
+ * @param _owner address The address which owns the funds.
+ * @param _spender address The address which will spend the funds.
+ * @return A uint256 specifying the amount of tokens still available for the spender.
+ */
+ function allowance(address _owner, address _spender)
+ public
+ view
+ returns (uint256) {
+ return allowed[_owner][_spender];
+ }
+
+ /**
+ * @dev Transfer token for a specified address
+ * @param _to The address to transfer to.
+ * @param _value The amount to be transferred.
+ */
+ function transfer(address _to, uint256 _value) public returns (bool) {
+ require(_value <= balances[msg.sender]);
+ require(_to != address(0));
+ balances[msg.sender] = balances[msg.sender].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ emit Transfer(msg.sender, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+ * Beware that changing an allowance with this method brings the risk that someone may use both the old
+ * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ * @param _spender The address which will spend the funds.
+ * @param _value The amount of tokens to be spent.
+ */
+ function approve(address _spender, uint256 _value) public returns (bool) {
+ allowed[msg.sender][_spender] = _value;
+ emit Approval(msg.sender, _spender, _value);
+ return true;
+ }
+
+ /**
+ * @dev Transfer tokens from one address to another
+ * @param _from address The address which you want to send tokens from
+ * @param _to address The address which you want to transfer to
+ * @param _value uint256 the amount of tokens to be transferred
+ */
+ function transferFrom(address _from, address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_value <= balances[_from]);
+ require(_value <= allowed[_from][msg.sender]);
+ require(_to != address(0));
+ balances[_from] = balances[_from].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+ emit Transfer(_from, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Increase the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To increment
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _addedValue The amount of tokens to increase the allowance by.
+ */
+ function increaseApproval(
+ address _spender,
+ uint256 _addedValue
+ )
+ public
+ returns (bool)
+ {
+ allowed[msg.sender][_spender] = (
+ allowed[msg.sender][_spender].add(_addedValue));
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+ /**
+ * @dev Decrease the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To decrement
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _subtractedValue The amount of tokens to decrease the allowance by.
+ */
+ function decreaseApproval(address _spender, uint256 _subtractedValue)
+ public
+ returns (bool) {
+ uint256 oldValue = allowed[msg.sender][_spender];
+ if (_subtractedValue >= oldValue) {
+ allowed[msg.sender][_spender] = 0;
+ }
+ else {
+ allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+ }
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+
+ /**
+ * @dev Total number of tokens in existence
+ */
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ /**
+ * @dev Gets the balance of the specified address.
+ * @param _owner The address to query the the balance of.
+ * @return An uint256 representing the amount owned by the passed address.
+ */
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| BurnableToken.sol | +100% | +42/42 | +100% | +8/8 | +100% | +11/11 | +100% | +42/42 | +|
| DividendToken.sol | +95.83% | +23/24 | +100% | +4/4 | +90.91% | +10/11 | +96.55% | +28/29 | +|
| DividendTokenERC20.sol | +100% | +33/33 | +83.33% | +10/12 | +100% | +11/11 | +100% | +37/37 | +|
| GovernedToken.sol | +70% | +7/10 | +25% | +1/4 | +75% | +3/4 | +58.33% | +7/12 | +|
| GovernedTokenERC20.sol | +0% | +0/10 | +0% | +0/4 | +0% | +0/4 | +0% | +0/12 | +|
| MintableToken.sol | +100% | +13/13 | +100% | +2/2 | +100% | +5/5 | +100% | +14/14 | +|
| StandardToken.sol | +100% | +29/29 | +100% | +12/12 | +100% | +8/8 | +100% | +29/29 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 | + + + + + + + + + +149× +27× + +122× +122× +121× + + + + + + + +109× + + + + +497× +493× + + + + +474× +474× +473× + + + + + + + +1× + + + + | pragma solidity 0.4.24;
+
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+// @title SafeMath: overflow/underflow checks
+// @notice Math operations with safety checks that throw on error
+library SafeMath {
+
+ // @notice Multiplies two numbers, throws on overflow.
+ function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+ if (a == 0) {
+ return 0;
+ }
+ uint256 c = a * b;
+ assert(c / a == b);
+ return c;
+ }
+
+ // @notice Integer division of two numbers, truncating the quotient.
+ function div(uint256 a, uint256 b) internal pure returns (uint256) {
+ // assert(b > 0); // Solidity automatically throws 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 a / b;
+ }
+
+ // @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
+ function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+ assert(b <= a);
+ return a - b;
+ }
+
+ // @notice Adds two numbers, throws on overflow.
+ function add(uint256 a, uint256 b) internal pure returns (uint256) {
+ uint256 c = a + b;
+ assert(c >= a);
+ return c;
+ }
+
+ // @notice Returns fractional amount
+ function getFractionalAmount(uint256 _amount, uint256 _percentage)
+ internal
+ pure
+ returns (uint256) {
+ return div(mul(_amount, _percentage), 100);
+ }
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| SafeMath.sol | +100% | +12/12 | +100% | +8/8 | +100% | +5/5 | +100% | +12/12 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + +4× +4× +4× +4× +4× +4× +3× +3× +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + + + + + + + + + +4× +4× +4× +3× +3× + + + + + + + + + + + + + + + + + + +4× +4× + + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+interface Burner { function burnEscrow(bytes32 _assetID) external returns (bool); }
+interface Escrow { function unlockEscrow(bytes32 _assetID) external returns (bool); }
+interface DB {
+ function addressStorage(bytes32 _key) external view returns (address);
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function setUint(bytes32 _key, uint _value) external;
+}
+interface TokenView {
+ function totalSupply() external view returns (uint);
+ function balanceOf(address _tokenHolder) external view returns (uint);
+}
+
+// @title A contract to manage the governance of assets on the platform
+// @author Kyle Dewhurst, MyBit Foundation
+// @notice All token holders of an asset can vote here
+contract AssetGovernance {
+ using SafeMath for uint256;
+
+ DB public database;
+
+
+ constructor(address _database)
+ public {
+ database = DB(_database);
+ }
+
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...
+ // @dev ie sha3(_assetID) or sha3(_assetID, someAddress)
+ function voteForExecution(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash, uint _amountToLock)
+ external
+ validAsset(_assetID)
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", executionID));
+ bytes32 investorVotesID = keccak256(abi.encodePacked("investorVotes", executionID, msg.sender));
+ uint256 numVotes = database.uintStorage(numVotesID);
+ uint256 investorVotes = database.uintStorage(investorVotesID);
+ require(lockTokens(_assetID, msg.sender, _amountToLock));
+ database.setUint(numVotesID, numVotes.add(_amountToLock));
+ database.setUint(investorVotesID, investorVotes.add(_amountToLock));
+ return true;
+ }
+
+
+ // @notice unlock tokens, removing them from the vote
+ // @dev _executionID should be looked up in event logs. it is equal to sha3(_assetID, _methodID, _parameterHash)
+ function unlockToken(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash, uint _amountToUnlock)
+ external
+ validAsset(_assetID)
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 voteTotalID = keccak256(abi.encodePacked("voteTotal", executionID));
+ bytes32 investorVotesID = keccak256(abi.encodePacked("investorVotes", executionID));
+ uint investorVotes = database.uintStorage(investorVotesID);
+ uint totalVotes = database.uintStorage(voteTotalID);
+ require(investorVotes <= _amountToUnlock); // 1 vote = 1 token
+ database.setUint(voteTotalID, totalVotes.sub(_amountToUnlock));
+ database.setUint(investorVotesID, investorVotes.sub(_amountToUnlock));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Public Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Checks that 1/3 or more of token holders agreed on function call
+ function isConsensusReached(address _executingContract, bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ TokenView assetToken = TokenView(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ bytes32 executionID = keccak256(abi.encodePacked(_executingContract, _assetID, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", executionID));
+ uint256 numTokens = assetToken.totalSupply();
+ return database.uintStorage(numVotesID).mul(100).div(numTokens) >= 33;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Internal Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice lock asset tokens to be able to vote
+ // @dev keeps track of how many assetTokens this investor has locked (for GovernedToken checks)
+ function lockTokens(bytes32 _assetID, address _investor, uint _amount)
+ internal
+ returns (bool) {
+ TokenView assetToken = TokenView(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint numTokensLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)));
+ require(_amount <= assetToken.balanceOf(_investor).sub(numTokensLocked));
+ database.setUint(keccak256(abi.encodePacked("tokensLocked", _assetID, _investor)), numTokensLocked.add(_amount));
+ return true;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ /*
+ modifier hasConsensus(bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash) {
+ require(isConsensusReached(address(this), _assetID, _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ }
+ */
+
+ // @notice reverts if the asset does not have a token address set in the database
+ modifier validAsset(bytes32 _assetID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))) != address(0));
+ _;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/ERC20.sol';
+
+
+// @title A contract which allows for platform owners to come to consensus on important functionality
+// @notice Can hold any number of owners. Each getting 1 vote.
+// @dev An owner has already been initialized when database is deployed
+// @author Kyle Dewhurst, MyBit Foundation
+contract CollectiveOwned {
+ using SafeMath for uint256;
+
+ Database public database;
+
+ // @param (address) _database = the address of the platform database
+ // @param (uint) _baseQuorum = the percentage of owners needed to approve a function call
+ constructor(address _database, uint256 _baseQuorum)
+ public {
+ database = Database(_database);
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("setQuorumLevel(address, bytes4, uint256)")));
+ bytes32 functionID = keccak256(abi.encodePacked(address(this), methodID));
+ database.setUint(functionID, _baseQuorum); // the initial quorum level to set further quorum levels
+ }
+
+ // @notice any owner on the platform can call this function to add a new user if it has receieve quorum level of signatures
+ // @notice must
+ // @param (address) _newOwner the address of the new owner
+ function addOwner(address _newOwner)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_newOwner)))
+ onlyOwner {
+ uint numOwners = database.uintStorage(keccak256(abi.encodePacked("numberOfOwners")));
+ database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
+ database.setUint(keccak256(abi.encodePacked("numberOfOwners")), numOwners.add(1));
+ }
+
+ // @notice any owner can call this function to remove an owner if the the function receives quorum level of signatures
+ // @param (address) _owner = the owner to be removed from the group of owners
+ function removeOwner(address _owner)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_owner)))
+ onlyOwner {
+ database.deleteBool(keccak256(abi.encodePacked("owner", _owner)));
+ }
+
+ // @notice restricts a function, forcing it to require _quorumLevel of votes to be executed
+ function setQuorumLevel(address _contractAddress, bytes4 _methodID, uint256 _quorumLevel)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_contractAddress, _methodID, _quorumLevel)))
+ returns (bool) {
+ bytes32 functionID = keccak256(abi.encodePacked(_contractAddress, _methodID));
+ database.setUint(functionID, _quorumLevel);
+ return true;
+ }
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...ie sha3(true, 55)
+ function voteForExecution(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ external
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfSignatures", executionID));
+ uint256 numSignatures = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numSignatures.add(1));
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // View Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function isQuorumReached(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ uint256 quorumLevel = database.uintStorage(keccak256(abi.encodePacked(_contractAddress, _methodID)));
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ uint256 numOwners = database.uintStorage(keccak256(abi.encodePacked("numberOfOwners")));
+ // check that number of signatures are greater than required quorum
+ return database.uintStorage(numVotesID).mul(100).div(numOwners) >= quorumLevel;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(isQuorumReached(address(this), _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ database.deleteBool(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+ event LogOwnerChanged(address indexed _previousOwner, address indexed _newOwner);
+ event LogFunctionAuthorized(address indexed _owner, string indexed _functionName, bytes32 indexed _beneficiary, bytes32 _authHash);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 | + + + + + + + + + + + + + + +4× + + + + + + + +3× +3× + + + + + + + +3× +3× + + + + +7× +6× + + + + + + + | pragma solidity 0.4.24;
+
+
+import '../database/Database.sol';
+
+// @title A contract which allows for the freezing of functionality within the platform.
+// @dev only valid with a single owned ownership model
+// @author Kyle Dewhurst, MyBit Foundation
+contract Pausible {
+
+ Database public database;
+
+ // @notice constructor: initialize database instance
+ constructor(address _database)
+ public {
+ database = Database(_database);
+ }
+
+ // @notice This will pause all critical activity for the supplied address
+ // @param: The address of the contract which is to be paused\
+ function pause(address _contract)
+ onlyOwner
+ public {
+ database.setBool(keccak256(abi.encodePacked("paused", _contract)), true);
+ emit LogPaused(_contract, msg.sender);
+ }
+
+ // @notice This will unpause all critical activity for the supplied address
+ // @param: The address of the contract which is to be unpaused
+ function unpause(address _contract)
+ onlyOwner
+ public {
+ database.deleteBool(keccak256(abi.encodePacked("paused", _contract)));
+ emit LogUnpaused(_contract, msg.sender);
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner() {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ event LogPaused(address indexed _contract, address _owner);
+ event LogUnpaused(address indexed _contract, address _owner);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 | + + + + + + + + + + + + +2× + + + + + + +1× +1× +1× + + + + +2× +1× + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+
+// @title A contract for managing a single platform owner
+// @dev Single owned platforms store owner as an address
+// @author Kyle Dewhurst, MyBit Foundation
+contract SingleOwned {
+
+ Database public database;
+
+ // @notice constructor: initiate database instance
+ constructor(address _database) public {
+ database = Database(_database);
+ }
+
+ // @notice Transfer ownership to to a new owner
+ function changeOwner(address _newOwner)
+ public
+ onlyOwner {
+ database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
+ database.setBool(keccak256(abi.encodePacked("owner", msg.sender)), false);
+ emit OwnershipTransferred(msg.sender, _newOwner);
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner() {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+ event OwnershipTransferred(address indexed owner, address indexed pendingOwner);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+import '../interfaces/ERC20.sol';
+
+
+// @title A contract which allows for token holders to authorize particular functions to be called
+// @notice Token holders must lock their tokens against a particular function
+// @notice Token holders can unlock their tokens, removing their vote
+// @dev An owner has already been initialized when database is deployed
+// @author Kyle Dewhurst, MyBit Foundation
+contract TokenGovernance {
+ using SafeMath for uint256;
+
+ Database public database;
+
+ ERC20 public governanceToken;
+
+
+
+ // @dev methodID = bytes4(sha3("functionName(parameterType, parameterType)")
+ // @dev functionID = sha3(contractAddress, methodID)
+ // @dev numVotes is sha3(contractAddress, methodID, sha3(parameter, parameter)))
+ // @dev quorumLevel = percentage of tokens required to be locked for the execution of a function
+
+
+ // @notice initiator of the platform sets the initial functions quorum level
+ // @notice quorum level dictates the number of votes required for that function to be executed
+ constructor(address _database, uint256 _baseQuorum)
+ public {
+ governanceToken = ERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ database = Database(_database);
+ governanceToken = ERC20(governanceToken);
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("setQuorumLevel(address, bytes4, uint256)")));
+ bytes32 functionID = keccak256(abi.encodePacked(address(this), methodID));
+ database.setUint(functionID, _baseQuorum); // the initial quorum level to set further quorum levels
+ }
+
+ // @notice If restricted it will have to be called from address(this) using a voting proccess on signForFunctionCall
+ function setQuorumLevel(address _contractAddress, bytes4 _methodID, uint256 _quorumLevel)
+ external
+ isRestricted(msg.sig, keccak256(abi.encodePacked(_contractAddress, _methodID, _quorumLevel)))
+ returns (bool) {
+ bytes32 functionID = keccak256(abi.encodePacked(_contractAddress, _methodID));
+ database.setUint(functionID, _quorumLevel);
+ return true;
+ }
+
+ // @param (bytes32) _parameterHash = The hash of the exact parameter to be called for function...ie sha3(true, 55)
+ function voteForExecution(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash, uint256 _voteAmount)
+ external
+ returns (bool) {
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ require(lockTokens(_voteAmount, executionID));
+ uint256 numVotes = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numVotes.add(_voteAmount));
+ return true;
+ }
+
+
+ function unlockTokens(bytes32 _executionID)
+ external
+ returns (bool) {
+ bytes32 voteID = keccak256(abi.encodePacked("tokenVotesLocked", _executionID, msg.sender));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", _executionID));
+ uint256 amountLocked = database.uintStorage(voteID);
+ uint256 numVotes = database.uintStorage(numVotesID);
+ database.setUint(numVotesID, numVotes.sub(amountLocked));
+ governanceToken.transfer(msg.sender, amountLocked);
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Internal Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function lockTokens(uint _amountToLock, bytes32 _executionID)
+ internal
+ returns (bool) {
+ bytes32 voteID = keccak256(abi.encodePacked("tokenVotesLocked", _executionID, msg.sender));
+ require(governanceToken.transferFrom(msg.sender, address(this), _amountToLock));
+ uint256 amountLocked = database.uintStorage(voteID);
+ database.setUint(voteID, amountLocked.add(_amountToLock));
+ return true;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // View Functions
+ //------------------------------------------------------------------------------------------------------------------
+
+ function isQuorumReached(address _contractAddress, bytes4 _methodID, bytes32 _parameterHash)
+ public
+ view
+ returns (bool) {
+ uint256 quorumLevel = database.uintStorage(keccak256(abi.encodePacked(_contractAddress, _methodID)));
+ bytes32 executionID = keccak256(abi.encodePacked(_contractAddress, _methodID, _parameterHash));
+ bytes32 numVotesID = keccak256(abi.encodePacked("numberOfVotes", executionID));
+ uint256 numTokens = governanceToken.totalSupply();
+ // check that number of signatures are greater than required quorum
+ return database.uintStorage(numVotesID).mul(100).div(numTokens) >= quorumLevel;
+ }
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Modifiers
+ //------------------------------------------------------------------------------------------------------------------
+
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier isRestricted(bytes4 _methodID, bytes32 _parameterHash) {
+ require(isQuorumReached(address(this), _methodID, _parameterHash)); // owners must have agreed on function + parameters
+ _;
+ // remove votes from function call
+ database.deleteUint(keccak256(abi.encodePacked(address(this), _methodID, _parameterHash)));
+ }
+
+ // @notice reverts if caller is not the owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
+ _;
+ }
+
+
+ //------------------------------------------------------------------------------------------------------------------
+ // Events
+ //------------------------------------------------------------------------------------------------------------------
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetGovernance.sol | +72% | +18/25 | +62.5% | +5/8 | +83.33% | +5/6 | +70.97% | +22/31 | +|
| CollectiveOwned.sol | +0% | +0/17 | +0% | +0/4 | +0% | +0/8 | +0% | +0/26 | +|
| Pausible.sol | +100% | +4/4 | +100% | +2/2 | +100% | +4/4 | +100% | +7/7 | +|
| SingleOwned.sol | +100% | +3/3 | +100% | +2/2 | +100% | +3/3 | +100% | +6/6 | +|
| TokenGovernance.sol | +0% | +0/28 | +0% | +0/8 | +0% | +0/8 | +0% | +0/37 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 | + + + + + + + + + + + + + + + + + + + + +3× + + + + + + + +4× +3× +3× +3× +3× +3× +3× +3× + + + + + + + + + +10× +9× +8× +8× +8× +8× +8× + +1× + + + +7× +7× +7× +7× +7× + +5× +5× +2× + +3× +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + + + + +2× +2× +2× + + + + + + + + + | pragma solidity 0.4.24;
+
+ import "../math/SafeMath.sol";
+ import "../interfaces/DBInterface.sol";
+ import "../interfaces/DivToken.sol";
+ import "../interfaces/BurnableERC20.sol";
+
+ interface Governance { function isConsensusReached(address _thisContract, bytes4 _methodID, bytes32 _parameterHash) external view returns (bool); }
+
+ // @title A contract to hold escrow as collateral against assets
+ // @author Kyle Dewhurst, MyBit Foundation
+ // @notice AssetManager can lock his escrow in this contract and retrieve it if asset funding fails or successfully returns ROI
+ contract AssetManagerEscrow {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+
+ // @notice constructor: initializes database
+ // @param: the address for the database contract used by this platform
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @dev assetID can be computed beforehand with sha3(msg.sender, _amountToRaise, _operatorID, _assetURI))
+ // @dev anybody can make the assetManager escrow if he leaves this contract with approval to transfer
+ function lockEscrow(bytes32 _assetID, uint _amount)
+ public
+ returns (bool) {
+ require(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))) == address(0));
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, msg.sender));
+ address tokenAddress = database.addressStorage(keccak256(abi.encodePacked("platformToken")));
+ Erequire(BurnableERC20(tokenAddress).transferFrom(msg.sender, address(this), _amount));
+ database.setUint(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID)), _amount);
+ database.setAddress(keccak256(abi.encodePacked("assetManager", _assetID)), msg.sender);
+ emit LogEscrowLocked(_assetID, assetManagerEscrowID, msg.sender, _amount);
+ return true;
+ }
+
+
+ // @notice assetManager can unlock his escrow here once funding fails or asset returns sufficient ROI
+ // @dev asset must have fundingDeadline = 0 or have ROI > 25%
+ // @dev returns escrow according to ROI. 25% ROI returns 25% of escrow, 50% ROI returns 50% of escrow etc...
+ function unlockEscrow(bytes32 _assetID)
+ public
+ returns (bool) {
+ require(database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))) == msg.sender);
+ require(database.uintStorage(keccak256(abi.encodePacked("fundingDeadline", _assetID))) < now);
+ BurnableERC20 burnToken = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, msg.sender));
+ uint escrowRedeemed = database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID)));
+ uint unlockAmount = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).sub(escrowRedeemed);
+ if(!database.boolStorage(keccak256(abi.encodePacked("crowdsaleFinalized", _assetID)))){
+ //If we're past deadline but crowdsale did NOT finalize, release all escrow
+ Erequire(removeAssetManager(_assetID, assetManagerEscrowID));
+ }
+ else {
+ //Past the deadline with a successful funding. Only pay back based on ROI
+ DivToken assetToken = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ uint roi = assetToken.assetIncome().mul(100).div(assetToken.totalSupply()); // Scaled up by 10^2 (approaches 100 as asset income increases)
+ uint roiCheckpoints = roi.div(25); // How many quarterly increments have been reached?
+ uint quarterEscrow = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).div(4);
+ require(roiCheckpoints <= 4 && roiCheckpoints > 0); // Can't unlock escrow past 100% ROI
+ // multiply the number of quarterly increments by a quarter of the escrow and subtract the escrow already redeemed.
+ unlockAmount = roiCheckpoints.mul(quarterEscrow).sub(escrowRedeemed);
+ require(unlockAmount > 0);
+ database.setUint(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID)), escrowRedeemed.add(unlockAmount));
+ }
+ Erequire(burnToken.transfer(msg.sender, unlockAmount));
+ return true;
+ }
+
+
+ // @notice investors can vote to call this function for the new assetManager to then call
+ // @dev new assetManager must approve this contract to transfer in and lock _ amount of platform tokens
+ function becomeAssetManager(bytes32 _assetID, address _oldAssetManager, uint256 _amount, bool _burn)
+ external
+ hasConsensus(_assetID, msg.sig, keccak256(abi.encodePacked(_assetID, _oldAssetManager, msg.sender, _amount, _burn)))
+ returns (bool) {
+ address currentAssetManager = database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID)));
+ require(currentAssetManager != msg.sender && currentAssetManager == _oldAssetManager);
+ bytes32 assetManagerEscrowID = keccak256(abi.encodePacked(_assetID, _oldAssetManager));
+ uint oldEscrowRemaining = database.uintStorage(keccak256(abi.encodePacked("assetManagerEscrow", assetManagerEscrowID))).sub(database.uintStorage(keccak256(abi.encodePacked("escrowRedeemed", assetManagerEscrowID))));
+ BurnableERC20 token = BurnableERC20(database.addressStorage(keccak256(abi.encodePacked("platformToken"))));
+ require(removeAssetManager(_assetID, assetManagerEscrowID));
+ if (_burn) { require(token.burn(oldEscrowRemaining)); }
+ else { require(token.transfer(_oldAssetManager, oldEscrowRemaining)); }
+ require(lockEscrow(_assetID, _amount));
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Internal Functions
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ function removeAssetManager(bytes32 _assetID, bytes32 _assetManagerEscrowID)
+ internal
+ returns (bool) {
+ database.deleteAddress(keccak256(abi.encodePacked("assetManager", _assetID)));
+ database.deleteUint(keccak256(abi.encodePacked("assetManagerEscrow", _assetManagerEscrowID)));
+ database.deleteUint(keccak256(abi.encodePacked("escrowRedeemed", _assetManagerEscrowID)));
+ return true;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice add this modifer to functions that you want multi-sig requirements for
+ // @dev function can only be called after at least n >= quorumLevel owners have agreed to call it
+ modifier hasConsensus(bytes32 _assetID, bytes4 _methodID, bytes32 _parameterHash) {
+ bytes32 numVotesID = keccak256(abi.encodePacked("voteTotal", keccak256(abi.encodePacked(address(this), _assetID, _methodID, _parameterHash))));
+ uint256 numTokens = DivToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID)))).totalSupply();
+ Irequire(database.uintStorage(numVotesID).mul(100).div(numTokens) >= 33, 'Consensus not reached');
+ _;
+ }
+
+
+ event LogEscrowBurned(bytes32 indexed _assetID, address indexed _assetManager, uint _amountBurnt);
+ event LogEscrowLocked(bytes32 indexed _assetID, bytes32 indexed _assetManagerEscrowID, address indexed _assetManager, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 | + + + + + + + + + + + + + + + + + + + + + + + + + + +3× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× + +1× +1× +1× + +1× +1× + + +1× +1× + +1× + + + + + + + +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× +1× + +1× +1× + + + + + + + +1× +1× + +1× + + + + + +2× +2× +2× +2× + + + + + + + + | pragma solidity 0.4.24;
+
+import "../interfaces/ERC20.sol";
+import "../interfaces/DBInterface.sol";
+import "../math/SafeMath.sol";
+
+interface DToken {
+ function withdraw() external returns (bool);
+ function getAmountOwed(address _user) external view returns (uint);
+ function balanceOf(address _tokenHolder) external view returns (uint);
+ function transfer(address _to, uint _amount) external returns (bool success);
+ function getERC20() external view returns (address);
+}
+
+// @title A dividend-token holding contract that locks tokens and retrieves dividends for assetManagers
+// @notice This contract receives newly minted tokens and retrieves Ether or ERC20 tokens received from the asset
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+contract AssetManagerFunds {
+ using SafeMath for uint256;
+
+ DBInterface public database;
+
+ uint256 private transactionNumber;
+
+ // @notice constructor: initializes database
+ constructor(address _database)
+ public {
+ database = DBInterface(_database);
+ }
+
+ // @notice asset manager can withdraw his dividend fee from assets here
+ // @param : bytes32 _assetID = the ID of this asset on the platform
+ function withdraw(bytes32 _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID))));
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID))));
+ require(address(token) != address(0));
+ uint amountOwed;
+ uint balanceBefore;
+ if (token.getERC20() == address(0)){
+ balanceBefore = address(this).balance;
+ amountOwed = token.getAmountOwed(address(this));
+ require(amountOwed > 0);
+ uint balanceAfter = balanceBefore.add(amountOwed);
+ require(token.withdraw());
+ require(address(this).balance == balanceAfter);
+ msg.sender.transfer(amountOwed);
+ }
+ else {
+ amountOwed = token.getAmountOwed(address(this));
+ require(amountOwed > 0);
+ balanceBefore = token.balanceOf(address(this));
+ require(token.withdraw());
+ require(token.balanceOf(address(this)).sub(amountOwed) == balanceBefore);
+ token.transfer(msg.sender, amountOwed);
+ }
+ return true;
+ }
+
+ function retrieveAssetManagerTokens(bytes32[] _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ Erequire(_assetID.length <= 42);
+ uint[] memory payoutAmounts = new uint[](_assetID.length);
+ address[] memory tokenAddresses = new address[](_assetID.length);
+ uint8 numEntries;
+ for(uint8 i = 0; i < _assetID.length; i++){
+ Erequire(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID[i]))) );
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID[i]))));
+ Erequire(address(token) != address(0));
+ uint tokensOwed = token.getAmountOwed(address(this));
+ Erequire(tokensOwed > 0);
+ DToken fundingToken = DToken(token.getERC20());
+ uint balanceBefore = fundingToken.balanceOf(address(this));
+ uint8 tokenIndex = containsAddress(tokenAddresses, address(token));
+ Iif (tokenIndex < _assetID.length) { payoutAmounts[tokenIndex] = payoutAmounts[tokenIndex].add(tokensOwed); }
+ else {
+ tokenAddresses[numEntries] = address(fundingToken);
+ payoutAmounts[numEntries] = tokensOwed;
+ numEntries++;
+ }
+ Erequire(token.withdraw());
+ Erequire(fundingToken.balanceOf(address(this)).sub(tokensOwed) == balanceBefore);
+ }
+
+ for(i = 0; i < numEntries; i++){
+ Erequire(ERC20(tokenAddresses[i]).transfer(msg.sender, payoutAmounts[i]));
+ }
+ return true;
+ }
+
+
+ function retrieveAssetManagerETH(bytes32[] _assetID)
+ external
+ nonReentrant
+ returns (bool) {
+ Erequire(_assetID.length <= 93);
+ uint weiOwed;
+ for(uint8 i = 0; i < _assetID.length; i++){
+ Erequire(msg.sender == database.addressStorage(keccak256(abi.encodePacked("assetManager", _assetID[i]))));
+ DToken token = DToken(database.addressStorage(keccak256(abi.encodePacked("tokenAddress", _assetID[i]))));
+ uint balanceBefore = address(this).balance;
+ uint amountOwed = token.getAmountOwed(address(this));
+ Erequire(amountOwed > 0);
+ uint balanceAfter = balanceBefore.add(amountOwed);
+ Erequire(token.withdraw());
+ Erequire(address(this).balance == balanceAfter);
+ weiOwed = weiOwed.add(amountOwed);
+ }
+ msg.sender.transfer(weiOwed);
+ return true;
+ }
+
+ // @notice returns the index if the address is in the list, otherwise returns list length + 1
+ function containsAddress(address[] _addressList, address _addr)
+ internal
+ pure
+ returns (uint8) {
+ for (uint8 i = 0; i < _addressList.length; i++){
+ Iif (_addressList[i] == _addr) return i;
+ }
+ return uint8(_addressList.length + 1);
+ }
+
+
+ // @notice prevents calls from re-entering contract
+ modifier nonReentrant() {
+ transactionNumber += 1;
+ uint256 localCounter = transactionNumber;
+ _;
+ Erequire(localCounter == transactionNumber);
+ }
+
+ function ()
+ payable
+ public {}
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 | + + + + + + + + + +8× + + + + + + + +10× +10× +10× +9× +9× +9× + + + + + + +3× +3× + + + + + + +3× +3× +2× +1× +1× +1× + + + + + + + +2× +2× + + + + + + + +3× +3× + + + + + + + + +14× +13× + + + + +5× +5× + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../database/Database.sol';
+import '../math/SafeMath.sol';
+
+contract Operators {
+
+ Database private database;
+
+ constructor(address _database) public {
+ database = Database(_database);
+ }
+
+ // @notice allows the platform owners to onboard a new operator.
+ // @notice operators will receive crowdfunding payments and are liable for producing/installing assets.
+ function registerOperator(address _operatorAddress, string _operatorURI)
+ external
+ onlyOwner {
+ Erequire(_operatorAddress != address(0));
+ bytes32 operatorID = keccak256(abi.encodePacked(_operatorURI));
+ require(database.addressStorage(keccak256(abi.encodePacked("operator", operatorID))) == address(0));
+ database.setAddress(keccak256(abi.encodePacked("operator", operatorID)), _operatorAddress);
+ database.setBytes32(keccak256(abi.encodePacked("operator", _operatorAddress)), operatorID);
+ emit LogOperatorRegistered(operatorID, _operatorURI);
+ }
+
+ // @notice owners can remove operators from the platform here
+ function removeOperator(bytes32 _operatorID)
+ external
+ onlyOwner {
+ database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
+ emit LogOperatorRemoved(_operatorID, msg.sender);
+ }
+
+
+ // @notice operator or owner can change the withdraw address of a registered operator
+ function changeOperatorAddress(bytes32 _operatorID, address _newAddress)
+ external {
+ address oldAddress = database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID)));
+ require(oldAddress != address(0));
+ require(msg.sender == oldAddress || database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ database.deleteAddress(keccak256(abi.encodePacked("operator", _operatorID)));
+ database.setAddress(keccak256(abi.encodePacked("operator", _operatorID)), _newAddress);
+ emit LogOperatorAddressChanged(_operatorID, msg.sender, _newAddress);
+ }
+
+ // @notice operator can choose which ERC20 tokens he's willing to accept as payment
+ function acceptERC20Token(bytes32 _operatorID, address _tokenAddress, bool _accept)
+ external
+ onlyOperator(_operatorID)
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("acceptsToken", _operatorID, _tokenAddress)), _accept);
+ return true;
+ }
+
+ // @notice operator can choose whether or not to accept Ether
+ function acceptEther(bytes32 _operatorID, bool _accept)
+ external
+ onlyOperator(_operatorID)
+ returns (bool) {
+ database.setBool(keccak256(abi.encodePacked("acceptsEther", _operatorID)), _accept);
+ return true;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Modifiers //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice Sender must be a registered owner
+ modifier onlyOwner {
+ require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))));
+ _;
+ }
+
+ // @notice Sender must be the operator address for this operatorID
+ modifier onlyOperator(bytes32 _operatorID) {
+ Erequire(database.addressStorage(keccak256(abi.encodePacked("operator", _operatorID))) == msg.sender);
+ _;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+ event LogOperatorRegistered(bytes32 indexed _operatorID, string _operatorURI);
+ event LogOperatorRemoved(bytes32 indexed _operatorID, address _owner);
+ event LogOperatorAddressChanged(bytes32 indexed _operatorID, address _oldAddress, address _newAddress);
+ event LogOperatorAcceptsToken(bytes32 indexed _operatorID, address _tokenAddress);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| AssetManagerEscrow.sol | +71.79% | +28/39 | +50% | +16/32 | +83.33% | +5/6 | +77.27% | +34/44 | +|
| AssetManagerFunds.sol | +68.42% | +39/57 | +31.25% | +15/48 | +85.71% | +6/7 | +68.75% | +44/64 | +|
| Operators.sol | +100% | +14/14 | +83.33% | +10/12 | +100% | +8/8 | +100% | +23/23 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 | + + + + +2× + + + + + | pragma solidity ^0.4.24;
+
+contract ApproveAndCallTest{
+ function receiveApproval(address from, uint tokens, address token, bytes data)
+ public {
+ emit LogApproval(from, tokens, token, data);
+ }
+
+ event LogApproval(address _from, uint _tokens, address _token, bytes _data);
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 | + + + + + + + + + + + + + + + + + + + + + + + + +8× + + + + + + + + + + + + + +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + + + + + + + + + +8× + + + + + + + + + + + + + +21× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+contract HashFunctions {
+
+ function toBytes(uint x)
+ external
+ pure
+ returns (bytes b) {
+ b = new bytes(32);
+ assembly { mstore(add(b, 32), x) }
+ }
+
+
+
+ function getMethodID(string _functionString)
+ public
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked(_functionString)));
+ }
+
+ function getAssetID(string _assetURI, uint _amountToRaise, bytes32 _operatorID)
+ public
+ view
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(msg.sender, _amountToRaise, _operatorID, _assetURI));
+ }
+
+ function getOrderID(bytes _assetID, address _user, uint _amount, uint _price, bool _buyOrder)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_assetID, _user, _amount, _price, _buyOrder));
+ }
+
+ function getFunctionInitiatorHash(address _param1, address _param2, bytes32 _param3)
+ external
+ pure
+ returns(bytes32) {
+ return keccak256(abi.encodePacked(_param1, _param2, "destroy", _param3));
+ }
+
+ function uintHash(uint _param)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param));
+ }
+
+ function getStakingID(address _staker, uint256 _blockNumber, uint256 _amount)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_staker, _blockNumber, _amount));
+ }
+
+ function stringHash(string _name)
+ external
+ pure
+ returns (bytes32){
+ return keccak256(abi.encodePacked(_name));
+ }
+
+ function addressHash(address _param)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param));
+ }
+
+
+ function contractHash(string _name)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked("contract", _name));
+ }
+
+ function stringAddress(string _param, address _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringString(string _param, string _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return (keccak256(abi.encodePacked(_param, _paramTwo)));
+ }
+
+ function stringBytes(string _param, bytes32 _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringUint(string _param, uint _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo));
+ }
+
+ function stringBytesAddress(string _param, bytes32 _paramTwo, address _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo, _paramThree));
+ }
+
+ function addressUintUint(address _param, uint _paramTwo, uint _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_param, _paramTwo, _paramThree));
+ }
+
+
+ function getAuthorizeHash(address _contractAddress, address _owner, string _fnName, bytes32 _recipient)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_contractAddress, _owner, _fnName, _recipient));
+ }
+
+ function uintUint(uint _paramOne, uint _paramTwo)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_paramOne, _paramTwo));
+ }
+
+
+ function uintUintUint(uint _paramOne, uint _paramTwo, uint _paramThree)
+ external
+ pure
+ returns (bytes32) {
+ return keccak256(abi.encodePacked(_paramOne, _paramTwo, _paramThree));
+ }
+
+ function currentTime()
+ external
+ view
+ returns (uint) {
+ return now;
+ }
+
+ function nullBytes()
+ external
+ pure
+ returns (bytes32) {
+ return bytes32(0);
+ }
+
+ function nullAddress()
+ external
+ pure
+ returns (address) {
+ return address(0);
+ }
+
+function ()
+public {
+ revert();
+}
+
+
+
+
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 | + + + + + + + + +3× + + + +1× + + + +2× + + + +2× + + + +1× + + + | pragma solidity 0.4.24;
+
+import "../math/SafeMath.sol";
+
+contract SafeMathWrapper {
+ using SafeMath for uint;
+ using SafeMath for bytes;
+
+ function multiply(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.mul(b);
+ }
+
+ function divide(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.div(b);
+ }
+
+ function subtract(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.sub(b);
+ }
+
+ function addto(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.add(b);
+ }
+
+ function fraction(uint256 a, uint256 b) external pure returns (uint256) {
+ return a.getFractionalAmount(b);
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 | + + + + + + + + + + + + + +1× +1× + + + + +4× + + + + + +2× +2× +2× +1× + + + + + + +1× + + + + | pragma solidity 0.4.24;
+
+import '../access/ERC20Burner.sol';
+import '../database/Database.sol';
+
+contract TestBurner {
+
+ ERC20Burner public burner;
+ Database public database;
+
+ uint public amountBurnt;
+
+ constructor(address _database, address _burner)
+ public {
+ burner = ERC20Burner(_burner);
+ database = Database(_database);
+ }
+
+ function burnTokensManualFee(uint _amount)
+ external {
+ require(burner.burn(msg.sender, _amount));
+ }
+
+ // Must set fee in ERC20Burner first
+ function burnTokens()
+ external {
+ bytes4 methodID = bytes4(keccak256(abi.encodePacked("burnTokens()")));
+ uint amountToBurn = database.uintStorage(keccak256(abi.encodePacked(methodID, address(this))));
+ require(burner.burn(msg.sender, amountToBurn));
+ amountBurnt += amountToBurn;
+ }
+
+ function getMethodID()
+ external
+ pure
+ returns (bytes4) {
+ return bytes4(keccak256(abi.encodePacked("burnTokens()")));
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + | pragma solidity ^0.4.24;
+
+contract WithdrawTest{
+
+ mapping(address => uint) public balances;
+
+ function withdraw()
+ external
+ returns (bool){
+ emit LogWithdraw(msg.sender, balances[msg.sender]);
+ uint amount = balances[msg.sender];
+ balances[msg.sender] = 0;
+ msg.sender.transfer(amount);
+ return true;
+ }
+
+ function deposit(address _receiver)
+ payable
+ external{
+ emit LogDeposit(_receiver, msg.value);
+ balances[_receiver] += msg.value;
+ }
+
+ event LogDeposit(address _receiver, uint _amount);
+ event LogWithdraw(address _receiver, uint _amount);
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ApproveAndCallTest.sol | +100% | +1/1 | +100% | +0/0 | +100% | +1/1 | +100% | +1/1 | +|
| HashFunctions.sol | +21.74% | +5/23 | +100% | +0/0 | +21.74% | +5/23 | +20.83% | +5/24 | +|
| SafeMathWrapper.sol | +100% | +5/5 | +100% | +0/0 | +100% | +5/5 | +100% | +5/5 | +|
| TestBurner.sol | +100% | +8/8 | +100% | +4/4 | +100% | +4/4 | +100% | +8/8 | +|
| WithdrawTest.sol | +33.33% | +2/6 | +100% | +0/0 | +50% | +1/2 | +28.57% | +2/7 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 | + + + + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2× +5× + +1× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import '../../interfaces/PullPayment.sol';
+
+// @title A contract made to equally distribute payments amongs a list of beneficiaries
+// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+// @notice This contract allows someone to leave ETH for a beneficiary
+// @dev assumes each beneficiary receives equal amount
+contract EqualDistribution {
+ using SafeMath for uint;
+
+ address[] public beneficiaries; // List of chosen beneficiaries
+
+ uint public totalReleased; // Total WEI so far released to beneficiaries
+
+ mapping (address => uint) public amountRedeemed; // Amount of WEI this address has already withdrawn from contract
+
+
+ // @notice constructor. Sets the beneficiaries and where the income to be distributed is coming from
+ // @param (address) _beneficiary = The ETH address of who is to receive the income. Could be a distribution contract.
+ constructor(address[] _beneficiaries)
+ public{
+ Erequire(_beneficiaries.length < 200);
+ beneficiaries = _beneficiaries;
+ }
+
+ // @notice allows beneficiaries to withdraw from contracts at different locations to be re-distributed here
+ // @dev can call withdraw() on any address if there are no parameters required. Fallback function will be triggered
+ // @param (address) _contractAddress = The address to call withdraw() on.
+ function getFunds(address _contractAddress)
+ external
+ returns (bool) {
+ PullPayment(_contractAddress).withdraw();
+ return true;
+ }
+
+ // @notice beneficiaries can withdraw their share of the income here
+ function withdraw()
+ external
+ returns (bool) {
+ uint amount = ((address(this).balance.add(totalReleased)).div(beneficiaries.length)).sub(amountRedeemed[msg.sender]);
+ amountRedeemed[msg.sender] = amountRedeemed[msg.sender].add(amount);
+ totalReleased = totalReleased.add(amount);
+ msg.sender.transfer(amount);
+ emit LogWithdraw(msg.sender, amount);
+ return true;
+ }
+
+ // @notice fallback function. Accepts Ether and updates income balance
+ function ()
+ public
+ payable {
+ emit LogPayment(msg.sender, msg.value);
+ }
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Constants
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // @notice check if the address is one of the beneficiaries
+ function isBeneficiary(address _beneficiary)
+ public
+ view
+ returns (bool) {
+ for (uint i = 0; i < beneficiaries.length; i++){
+ if (beneficiaries[i] == _beneficiary) { return true; }
+ }
+ return false;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Events
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ event LogPayment(address _sender, uint _amount);
+ event LogWithdraw(address _beneficiary, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | + + + + + + + + + + + + + + + +2× +2× +2× +2× +6× +6× + +2× + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import './StandardDistribution.sol';
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract FixedDistribution is StandardDistribution {
+ using SafeMath for uint;
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address[] _tokenHolders, uint[] _amount)
+ public {
+ Erequire(_tokenHolders.length < 200 && _tokenHolders.length == _amount.length);
+ uint _totalSupply;
+ tokenURI = _tokenURI;
+ for (uint8 i = 0; i < _tokenHolders.length; i++) {
+ _totalSupply = _totalSupply.add(_amount[i]);
+ balances[_tokenHolders[i]] = balances[_tokenHolders[i]].add(_amount[i]);
+ }
+ supply = _totalSupply;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 | + + + + + + + + + + + + + + + + + + + +1× +1× + + + + + + + + + +2× +2× +2× +2× + + + + + + + + +1× +1× +1× + + + + + + + + + +4× +3× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import './StandardDistribution.sol';
+
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBitFoundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract MintableDistribution is StandardDistribution{
+ using SafeMath for uint;
+
+ bool public mintingFinished = false;
+ address public minter;
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _minter)
+ public {
+ tokenURI = _tokenURI; // Set the id for reference
+ minter = _minter;
+ }
+
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount)
+ public
+ canMint
+ returns (bool) {
+ supply = supply.add(_amount);
+ balances[_to] = balances[_to].add(_amount);
+ emit Mint(_to, _amount);
+ return true;
+ }
+
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting()
+ public
+ canMint
+ returns (bool) {
+ mintingFinished = true;
+ emit MintFinished();
+ return true;
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+
+ // @notice modifier: Requires that minting hasn't finished
+ modifier canMint() {
+ require(!mintingFinished && msg.sender == minter);
+ _;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+
+ event Mint(address indexed to, uint256 amount);
+ event MintFinished();
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +4× +4× +4× +4× + + + + + + + + + + + + + + + + +1× +1× +1× + + + + + + +2× +2× +2× + + + + + + + + + + + +5× +5× + + + + + + + +1× + + + +1× + + + +7× + + + + + + + + + +4× +4× +4× + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import '../../math/SafeMath.sol';
+import '../../interfaces/PullPayment.sol';
+
+
+// @title Non-Transferable ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners can withdraw their share
+// @author Kyle Dewhurst, MyBitFoundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract StandardDistribution{
+ using SafeMath for uint;
+
+
+ uint public supply;
+ mapping (address => uint) internal balances;
+
+ string public tokenURI; // A reference to a URI containing further token information
+
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+ uint public assetIncome;
+ uint public valuePerToken;
+
+ mapping (address => uint) public claimableIncome;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice Updates claimableIncome, sends all wei to the token holder
+ function withdraw()
+ public
+ updateclaimableIncome(msg.sender)
+ returns (uint _amount) {
+ _amount = claimableIncome[msg.sender].div(scalingFactor);
+ delete claimableIncome[msg.sender];
+ msg.sender.transfer(_amount);
+ emit LogIncomeCollected(now, msg.sender, _amount);
+ }
+/*
+ // @notice allows beneficiaries to withdraw from contracts at different locations to be re-distributed here
+ // @dev can call withdraw() on any address if there are no parameters required. Fallback function will be triggered
+ // @param (address) _contractAddress = The address to call withdraw() on.
+ function getFunds(address _contractAddress)
+ external
+ returns (bool) {
+ PullPayment(_contractAddress).withdraw();
+ return true;
+ }
+
+*/
+ function issueDividends()
+ payable
+ public {
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(msg.value);
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+ // Fallback function: Accepts Ether and updates ledger (issues dividends)
+ function ()
+ payable
+ public {
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(msg.value);
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // View Functions
+ // ------------------------------------------------------------------------------------------------
+
+ // @notice Calculates how much value _user holds
+ function getTokenValue(address _user)
+ public
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_user]);
+ return valuePerTokenDifference.mul(balances[_user]);
+ }
+
+ // @notice Calculates how much wei user is owed. (new income + claimableIncome) / 10**32
+ function getUnclaimedAmount(address _user)
+ public
+ view
+ returns (uint) {
+ return (getTokenValue(_user).add(claimableIncome[_user]).div(scalingFactor));
+ }
+
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+ // ------------------------------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------------------------------
+
+ // Updates the amount owed to user while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateclaimableIncome(address _user) {
+ claimableIncome[_user] = claimableIncome[_user].add(getTokenValue(_user));
+ previousValuePerToken[_user] = valuePerToken;
+ _;
+ }
+
+
+ // ------------------------------------------------------------------------------------------------
+ // Events
+ // ------------------------------------------------------------------------------------------------
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(uint _block, address _address, uint _amount);
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| EqualDistribution.sol | +42.86% | +6/14 | +75% | +3/4 | +40% | +2/5 | +35.71% | +5/14 | +|
| FixedDistribution.sol | +100% | +6/6 | +50% | +1/2 | +100% | +1/1 | +100% | +7/7 | +|
| MintableDistribution.sol | +100% | +10/10 | +100% | +2/2 | +100% | +4/4 | +100% | +11/11 | +|
| StandardDistribution.sol | +100% | +15/15 | +100% | +0/0 | +100% | +8/8 | +100% | +18/18 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 | + + + + + + + + + + + + + + + + + + + + + + + + +12× +12× +12× +12× + + + + + + + + + + + +204× +203× +201× +201× +201× +201× + + + + + + + + + + + + + + +156× +156× +156× + + + + + + + + + + + +17× +16× +15× +15× +14× +14× + + + + + + + + + + + + + + +1× + +1× +1× + + + + + + + + + + + + + + +2× +2× +1× + + +1× + +2× +2× + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + + + + + + +40× +40× +39× +39× +39× +39× + + + + + + + + +2× + + + + + + + + +199× + + + + + + + + + + + + + +5× + + + + | pragma solidity 0.4.24;
+
+import "./StandardToken.sol";
+import "../../interfaces/BurnableERC20.sol";
+import "../../math/SafeMath.sol";
+
+// @title ERC20 token contract with burning capabilities
+// @notice Standard ERC20 contract with a deflationary supply.
+contract BurnableToken is BurnableERC20 {
+ using SafeMath for uint256;
+
+ string public tokenURI;
+
+ mapping(address => uint256) internal balances;
+
+ mapping (address => mapping (address => uint256)) internal allowed;
+
+ uint256 internal supply;
+
+
+ // @notice constructor: initialized
+ // @param (string) _tokenURI = The URI where information about this token can be found
+ // @param (uint) _totalSupply = The initial supply of the token
+ constructor(string _tokenURI, uint _totalSupply)
+ public {
+ supply = _totalSupply; // Update total supply
+ tokenURI = _tokenURI; // Set the id for reference
+ balances[msg.sender] = _totalSupply;
+ emit Transfer(address(0), msg.sender, _totalSupply); // Transfer event indicating token creation
+ }
+
+
+ /**
+ * @dev Transfer token for a specified address
+ * @param _to The address to transfer to.
+ * @param _value The amount to be transferred.
+ */
+ function transfer(address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_value <= balances[msg.sender]);
+ require(_to != address(0));
+ balances[msg.sender] = balances[msg.sender].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ emit Transfer(msg.sender, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+ * Beware that changing an allowance with this method brings the risk that someone may use both the old
+ * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ * @param _spender The address which will spend the funds.
+ * @param _value The amount of tokens to be spent.
+ */
+ function approve(address _spender, uint256 _value)
+ public
+ returns (bool) {
+ allowed[msg.sender][_spender] = _value;
+ emit Approval(msg.sender, _spender, _value);
+ return true;
+ }
+
+ /**
+ * @dev Transfer tokens from one address to another
+ * @param _from address The address which you want to send tokens from
+ * @param _to address The address which you want to transfer to
+ * @param _value uint256 the amount of tokens to be transferred
+ */
+ function transferFrom(address _from, address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_to != address(0)); // use burn instead
+ balances[_from] = balances[_from].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+ emit Transfer(_from, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Increase the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To increment
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _addedValue The amount of tokens to increase the allowance by.
+ */
+ function increaseApproval(address _spender, uint256 _addedValue)
+ public
+ returns (bool) {
+ allowed[msg.sender][_spender] = (
+ allowed[msg.sender][_spender].add(_addedValue));
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+ /**
+ * @dev Decrease the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To decrement
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _subtractedValue The amount of tokens to decrease the allowance by.
+ */
+ function decreaseApproval(address _spender, uint256 _subtractedValue)
+ public
+ returns (bool) {
+ uint256 oldValue = allowed[msg.sender][_spender];
+ if (_subtractedValue >= oldValue) {
+ allowed[msg.sender][_spender] = 0;
+ }
+ else {
+ allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+ }
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+
+
+ // ------------------------------------------------------------------------
+ // Removes senders tokens from supply.
+ // Lowers investor balance and totalSupply by _amount
+ // ------------------------------------------------------------------------
+ function burn(uint _amount)
+ public
+ returns (bool success) {
+ balances[msg.sender] = balances[msg.sender].sub(_amount);
+ supply = supply.sub(_amount);
+ emit LogBurn(msg.sender, _amount);
+ emit Transfer(msg.sender, address(0), _amount);
+ return true;
+ }
+
+ // ------------------------------------------------------------------------
+ // An approved sender can burn _amount tokens of investor _from
+ // Lowers investor balance and supply by _amount
+ // ------------------------------------------------------------------------
+ function burnFrom(address _from, uint _amount)
+ public
+ returns (bool success) {
+ balances[_from] = balances[_from].sub(_amount); // Subtract from the targeted balance
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); // Subtract from the sender's allowance
+ supply = supply.sub(_amount); // Update supply
+ emit LogBurn(_from, _amount);
+ emit Transfer(_from, address(0), _amount);
+ return true;
+ }
+
+
+
+ /**
+ * @dev Total number of tokens in existence
+ */
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ /**
+ * @dev Gets the balance of the specified address.
+ * @param _owner The address to query the the balance of.
+ * @return An uint256 representing the amount owned by the passed address.
+ */
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+
+ /**
+ * @dev Function to check the amount of tokens that an owner allowed to a spender.
+ * @param _owner address The address which owns the funds.
+ * @param _spender address The address which will spend the funds.
+ * @return A uint256 specifying the amount of tokens still available for the spender.
+ */
+ function allowance(address _owner, address _spender)
+ public
+ view
+ returns (uint256) {
+ return allowed[_owner][_spender];
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +4× +3× +1× + + + + + + + + + + + + +6× +5× +3× + + + + + + + + + + + +1× +1× +1× +1× + + + + + + + +10× +10× +10× +10× +10× + + + + + + + +7× +7× +7× +7× + + + + + + + + + + + + + + +4× +4× +4× + + + + + + + + + + + + +36× +36× + + + + + + + +4× + + + + + + + + + +32× +32× +32× + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import './MintableToken.sol';
+import '../../math/SafeMath.sol';
+import '../../interfaces/ApproveAndCallFallback.sol';
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive payments in the fallback function and token owners receive their share when transferring tokens.
+// @author Kyle Dewhurst & Peter Phillips MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract DividendToken is MintableToken {
+ using SafeMath for uint;
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+ uint public valuePerToken;
+ uint public assetIncome;
+
+ mapping (address => uint) public incomeOwed;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _owner)
+ public
+ MintableToken(_tokenURI, _owner){}
+
+ // @notice Transfer _amount tokens to address _to.
+ // @dev Sender must have enough tokens. Cannot send to 0x0.
+ // @param (address) _to = The address which will receive the tokens
+ // @param (uint) _amount = The amount of tokens to send
+ function transfer(address _to, uint _amount)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice A 3rd party can transfer tokens if investor approves them to do so
+ // @dev Transfer _amount of tokens if _from has allowed msg.sender to do so.
+ // @param (address) _from = The address who approved msg.sender to spend tokens
+ // @param (address) _to = The address who will receive the tokens
+ // @param (uint) _amount = The number of tokens to send
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ updateIncomeClaimed(_from)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_spender)
+ returns (bool success) {
+ allowed[msg.sender][_spender] = _amount;
+ emit Approval(msg.sender, _spender, _amount);
+ ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _data);
+ return true;
+ }
+
+ // @notice token holders can withdraw income here
+ function withdraw()
+ public
+ updateIncomeClaimed(msg.sender)
+ returns (bool) {
+ uint amount = incomeOwed[msg.sender].div(scalingFactor);
+ delete incomeOwed[msg.sender];
+ emit LogIncomeCollected(msg.sender, amount);
+ msg.sender.transfer(amount);
+ return true;
+ }
+
+ // @notice assets can send their income here to be collected by investors
+ function issueDividends()
+ payable
+ public
+ returns (bool) {
+ assetIncome = assetIncome.add(msg.value);
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ emit LogIncomeReceived(msg.sender, msg.value);
+ return true;
+ }
+
+ // @notice returns null address to specify this token accepts only Ether payments
+ function getERC20()
+ external
+ pure
+ returns(address){
+ return address(0);
+ }
+
+ // Fallback function: receives Ether and updates income ledger
+ function ()
+ payable
+ public {
+ assetIncome = assetIncome.add(msg.value);
+ valuePerToken = valuePerToken.add(msg.value.mul(scalingFactor).div(supply));
+ emit LogIncomeReceived(msg.sender, msg.value);
+ }
+
+
+ // ------------------------------------------------------------------------
+ // View functions
+ // ------------------------------------------------------------------------
+
+ // @notice Calculates how much more income is owed to investor since last calculation
+ function collectLatestPayments(address _investor)
+ private
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_investor]);
+ return valuePerTokenDifference.mul(balances[_investor]);
+ }
+
+ // @notice Calculates how much wei investor is owed. (points + incomeOwed) / 10**32
+ function getAmountOwed(address _investor)
+ public
+ view
+ returns (uint) {
+ return (collectLatestPayments(_investor).add(incomeOwed[_investor]).div(scalingFactor));
+ }
+
+ // ------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------
+
+ // Updates the amount owed to investor while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateIncomeClaimed(address _investor) {
+ incomeOwed[_investor] = incomeOwed[_investor].add(collectLatestPayments(_investor));
+ previousValuePerToken[_investor] = valuePerToken;
+ _;
+ }
+
+
+
+
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogIncomeCollected(address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +5× + + + + + + + + +3× +2× +1× + + + + + + + + +3× +2× +1× + + + + + + + + + + + +1× +1× +1× +1× + + + + + +6× +5× +5× +5× +5× +5× + + + + + + + +10× +10× +10× +10× +10× +10× + + + + + + + +2× +2× +2× +2× + +1× +1× + +2× + + + + + + + + + + + + +28× +28× + + + + + + + +4× + + + + + + +2× + + + + + + + + + +24× +24× +24× + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.24;
+
+import './MintableToken.sol';
+import '../../math/SafeMath.sol';
+import '../../interfaces/ERC20.sol';
+import '../../interfaces/ApproveAndCallFallback.sol';
+
+// @title ERC20 token contract with shared revenue distribution functionality.
+// @notice This token contract can receive ERC20 tokens as payments and token owners receive their share when transferring tokens.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// Credit goes to Nick Johnson for the dividend token https://medium.com/@weka/dividend-bearing-tokens-on-ethereum-42d01c710657
+contract DividendTokenERC20 is MintableToken {
+ using SafeMath for uint;
+
+ ERC20 public erc20;
+
+ // @notice Token Income Information
+ uint constant scalingFactor = 1e32;
+
+ uint public assetIncome;
+ uint public assetIncomeIssued;
+ uint public valuePerToken;
+
+
+ mapping (address => uint) public incomeClaimed;
+ mapping (address => uint) public previousValuePerToken;
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _owner, address _erc20Address)
+ public MintableToken(_tokenURI, _owner){
+ erc20 = ERC20(_erc20Address); //Set the address of the ERC20 token that will be issued as dividends
+ }
+
+
+ function transfer(address _to, uint _amount)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ updateIncomeClaimed(_from)
+ updateIncomeClaimed(_to)
+ returns (bool success) {
+ require(_to != address(this));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice Token holder can notify a contract that it has been approved to spend _amount of tokens
+ // @param (address) _spender = The contract to call after approval is done
+ // @param (uint) _amount = Number of tokens to send
+ // @param (bytes) _data = Bytes data to send along with the contract call
+ function approveAndCall(address _spender, uint _amount, bytes _data)
+ public
+ updateIncomeClaimed(msg.sender)
+ updateIncomeClaimed(_spender)
+ returns (bool success) {
+ allowed[msg.sender][_spender] = _amount;
+ emit Approval(msg.sender, _spender, _amount);
+ ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _data);
+ return true;
+ }
+
+ function issueDividends(uint _amount)
+ public
+ returns (bool){
+ require(_amount > 0);
+ Erequire(erc20.transferFrom(msg.sender, address(this), _amount));
+ valuePerToken = valuePerToken.add(_amount.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(_amount);
+ emit LogIncomeReceived(msg.sender, _amount);
+ return true;
+ }
+
+ // @notice Updates incomeClaimed, sends all wei to the token holder
+ function withdraw()
+ public
+ updateIncomeClaimed(msg.sender)
+ returns (bool) {
+ uint amount = incomeClaimed[msg.sender].div(scalingFactor);
+ delete incomeClaimed[msg.sender];
+ assetIncomeIssued = assetIncomeIssued.add(amount);
+ Erequire(erc20.transfer(msg.sender, amount));
+ emit LogIncomeCollected(msg.sender, amount);
+ return true;
+ }
+
+ //In case a investor transferred a token directly to this contract
+ //anyone can run this function to clean up the balances
+ //and distribute the difference to token holders
+ function checkForTransfers()
+ external {
+ uint bookBalance = assetIncome.sub(assetIncomeIssued);
+ uint actualBalance = erc20.balanceOf(address(this));
+ uint diffBalance = actualBalance.sub(bookBalance);
+ if(diffBalance > 0){
+ //Update value per token
+ valuePerToken = valuePerToken.add(diffBalance.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(diffBalance);
+ }
+ emit LogCheckBalance(diffBalance);
+ }
+
+
+ // ------------------------------------------------------------------------
+ // View functions
+ // ------------------------------------------------------------------------
+
+ // @notice Calculates how much value _investor holds
+ function collectLatestPayments(address _investor)
+ public
+ view
+ returns (uint) {
+ uint valuePerTokenDifference = valuePerToken.sub(previousValuePerToken[_investor]);
+ return valuePerTokenDifference.mul(balances[_investor]);
+ }
+
+ // @notice Calculates how much wei investor is owed. (points + incomeClaimed) / 10**32
+ function getAmountOwed(address _investor)
+ public
+ view
+ returns (uint) {
+ return (collectLatestPayments(_investor).add(incomeClaimed[_investor]).div(scalingFactor));
+ }
+
+ function getERC20()
+ external
+ view
+ returns(address){
+ return address(erc20);
+ }
+
+ // ------------------------------------------------------------------------
+ // Modifiers
+ // ------------------------------------------------------------------------
+
+ // Updates the amount owed to investor while holding tokenSupply
+ // @dev must be called before transfering tokens
+ modifier updateIncomeClaimed(address _investor) {
+ incomeClaimed[_investor] = incomeClaimed[_investor].add(collectLatestPayments(_investor));
+ previousValuePerToken[_investor] = valuePerToken;
+ _;
+ }
+
+ // Fallback function:
+ // Only works with ERC223
+ // Can't currently detect which token
+ /*
+ function tokenFallback(address _from, uint _value, bytes _data)
+ public {
+ valuePerToken = valuePerToken.add(_value.mul(scalingFactor).div(supply));
+ assetIncome = assetIncome.add(_value);
+ emit LogIncomeReceived(_from, _value);
+ }
+ */
+
+ event LogIncomeReceived(address indexed _sender, uint _paymentAmount);
+ event LogCheckBalance(uint _difference);
+ event LogIncomeCollected(address _address, uint _amount);
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 | + + + + + + + + + + + + + + + + + + + + + + + + + +1× + + + + + + +1× + + + + + + + + + + + + + + + + + + +1× +1× +1× +1× +1× + + + + | pragma solidity 0.4.24;
+
+import "./DividendToken.sol";
+import "../../math/SafeMath.sol";
+
+
+// @notice give GovernedToken access to view uint and bytes32 storage
+interface DBAccess {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+}
+
+// @title A Dividend token that has governance features .
+// @notice This token contract can receive ERC20 tokens as payments and token owners can lock tokens while submitting votes
+// @dev Dividend tokens aren't actually locked, but restricted from transferring to avoid locking contravt having to distribute dividends.
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+contract GovernedToken is DividendToken {
+ using SafeMath for uint;
+
+ DBAccess public database;
+
+
+ // @notice constructor: initialized
+ constructor(address _database, string _tokenURI, address _owner)
+ public
+ DividendToken(_tokenURI, _owner){
+ database = DBAccess(_database);
+ }
+
+ // @notice Standard DividendToke transfer function, which checks for locked tokens before sending
+ function transfer(address _to, uint _amount)
+ public
+ returns (bool success) {
+ Irequire(_amount <= getAmountAvailable(msg.sender));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice Standard DividendToke transferFrom function, which checks for locked tokens before sending
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(_from));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice returns the amount of tokens _investor has locked for this asset
+ function getAmountAvailable(address _investor)
+ public
+ view
+ returns (uint) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", address(this))));
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", assetID, _investor)));
+ uint balance = balances[_investor];
+ uint available = balance.sub(amountLocked);
+ return available;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity 0.4.24;
+
+import "./DividendTokenERC20.sol";
+import "../../math/SafeMath.sol";
+
+// @notice give GovernedToken access to view uint and bytes32 storage
+interface DBAccess {
+ function uintStorage(bytes32 _key) external view returns (uint);
+ function bytes32Storage(bytes32 _key) external view returns (bytes32);
+}
+
+// @title A Dividend token that has governance features and receives ERC20 tokens as payment
+// @notice This token contract can receive ERC20 tokens as payments and token owners can lock tokens while submitting votes
+// @author Kyle Dewhurst & Peter Phillips, MyBit Foundation
+// @dev Dividend tokens aren't actually locked, but restricted from transferring to avoid locking contravt having to distribute dividends.
+contract GovernedTokenERC20 is DividendTokenERC20{
+ DBAccess public database;
+
+
+ // @notice constructor: initializes database and DividendTokenERC20
+ // @param (address) _database = the address of the platform database
+ // @param (string) _tokenURI = The URI where details of the token (asse) can be found
+ // @param (address) _owner = The minting authority for this token
+ // @param (address) _erc20Address = The address of the erc20 token to be sent for dividends
+ constructor(address _database, string _tokenURI, address _owner, address _erc20Address)
+ public
+ DividendTokenERC20(_tokenURI, _owner, _erc20Address){
+ database = DBAccess(_database);
+ }
+
+ // @notice Standard DividendToke transfer function, which checks for locked tokens before sending
+ function transfer(address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(msg.sender));
+ super.transfer(_to, _amount);
+ return true;
+ }
+
+ // @notice Standard DividendToke transferFrom function, which checks for locked tokens before sending
+ function transferFrom(address _from, address _to, uint _amount)
+ public
+ returns (bool success) {
+ require(_amount <= getAmountAvailable(_from));
+ super.transferFrom(_from, _to, _amount);
+ return true;
+ }
+
+ // @notice returns the amount of tokens _investor has locked for this asset
+ function getAmountAvailable(address _investor)
+ public
+ view
+ returns (uint) {
+ bytes32 assetID = database.bytes32Storage(keccak256(abi.encodePacked("assetTokenID", address(this))));
+ uint amountLocked = database.uintStorage(keccak256(abi.encodePacked("tokensLocked", assetID, _investor)));
+ uint balance = balances[_investor];
+ uint available = balance.sub(amountLocked);
+ return available;
+ }
+
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 | + + + + + + + + + + + + + + + + + + + +17× +17× +17× + + + + + + + + + + +43× +43× +43× +43× +43× + + + + + + + +7× +7× +7× + + + + + + +2× + + + + +51× +50× + + + + + + | pragma solidity 0.4.24;
+
+import "./StandardToken.sol";
+
+
+/**
+ * @title Mintable token
+ * @dev Simple ERC20 Token example, with mintable token creation
+ * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
+ */
+contract MintableToken is StandardToken {
+
+ bool public mintingFinished;
+ address internal minter;
+ string internal tokenURI; // A reference to a URI containing further token information
+
+
+ // @notice constructor: initialized
+ constructor(string _tokenURI, address _minter)
+ public {
+ tokenURI = _tokenURI; // Set the id for reference
+ minter = _minter;
+ supply = 0;
+ }
+
+
+ // @dev Function to mint tokens
+ // @param _to The address that will receive the minted tokens.
+ // @param _amount The amount of tokens to mint.
+ function mint(address _to, uint256 _amount)
+ public
+ canMint
+ returns (bool) {
+ supply = supply.add(_amount);
+ balances[_to] = balances[_to].add(_amount);
+ emit Mint(_to, _amount);
+ emit Transfer(address(0), _to, _amount);
+ return true;
+ }
+
+ // @dev Function to stop minting new tokens.
+ function finishMinting()
+ public
+ canMint
+ returns (bool) {
+ mintingFinished = true;
+ emit MintFinished();
+ return true;
+ }
+
+ function getTokenURI()
+ external
+ view
+ returns (string) {
+ return tokenURI;
+ }
+
+ // @notice modifier: Requires that minting hasn't finished
+ modifier canMint() {
+ require(!mintingFinished && msg.sender == minter);
+ _;
+ }
+
+ event Mint(address indexed to, uint256 amount);
+ event MintFinished();
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +17× + + + + + + + + +5× +3× +2× +2× +2× +2× + + + + + + + + + + + + +11× +11× +11× + + + + + + + + + + + +7× +6× +5× +4× +4× +4× +4× +4× + + + + + + + + + + + + + + + + + + +1× + +1× +1× + + + + + + + + + + + + + + +2× +2× +1× + + +1× + +2× +2× + + + + + + + +36× + + + + + + + + +55× + + + + + | pragma solidity 0.4.24;
+
+import "../../interfaces/ERC20.sol";
+import "../../math/SafeMath.sol";
+
+
+/**
+ * @title Standard ERC20 token
+ *
+ * @dev Implementation of the basic standard token.
+ * https://github.com/ethereum/EIPs/issues/20
+ * Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
+ */
+contract StandardToken is ERC20 {
+ using SafeMath for uint256;
+
+ mapping(address => uint256) internal balances;
+
+ mapping (address => mapping (address => uint256)) internal allowed;
+
+ uint256 internal supply;
+
+
+ /**
+ * @dev Function to check the amount of tokens that an owner allowed to a spender.
+ * @param _owner address The address which owns the funds.
+ * @param _spender address The address which will spend the funds.
+ * @return A uint256 specifying the amount of tokens still available for the spender.
+ */
+ function allowance(address _owner, address _spender)
+ public
+ view
+ returns (uint256) {
+ return allowed[_owner][_spender];
+ }
+
+ /**
+ * @dev Transfer token for a specified address
+ * @param _to The address to transfer to.
+ * @param _value The amount to be transferred.
+ */
+ function transfer(address _to, uint256 _value) public returns (bool) {
+ require(_value <= balances[msg.sender]);
+ require(_to != address(0));
+ balances[msg.sender] = balances[msg.sender].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ emit Transfer(msg.sender, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+ * Beware that changing an allowance with this method brings the risk that someone may use both the old
+ * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+ * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ * @param _spender The address which will spend the funds.
+ * @param _value The amount of tokens to be spent.
+ */
+ function approve(address _spender, uint256 _value) public returns (bool) {
+ allowed[msg.sender][_spender] = _value;
+ emit Approval(msg.sender, _spender, _value);
+ return true;
+ }
+
+ /**
+ * @dev Transfer tokens from one address to another
+ * @param _from address The address which you want to send tokens from
+ * @param _to address The address which you want to transfer to
+ * @param _value uint256 the amount of tokens to be transferred
+ */
+ function transferFrom(address _from, address _to, uint256 _value)
+ public
+ returns (bool) {
+ require(_value <= balances[_from]);
+ require(_value <= allowed[_from][msg.sender]);
+ require(_to != address(0));
+ balances[_from] = balances[_from].sub(_value);
+ balances[_to] = balances[_to].add(_value);
+ allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+ emit Transfer(_from, _to, _value);
+ return true;
+ }
+
+ /**
+ * @dev Increase the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To increment
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _addedValue The amount of tokens to increase the allowance by.
+ */
+ function increaseApproval(
+ address _spender,
+ uint256 _addedValue
+ )
+ public
+ returns (bool)
+ {
+ allowed[msg.sender][_spender] = (
+ allowed[msg.sender][_spender].add(_addedValue));
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+ /**
+ * @dev Decrease the amount of tokens that an owner allowed to a spender.
+ * approve should be called when allowed[_spender] == 0. To decrement
+ * allowed value is better to use this function to avoid 2 calls (and wait until
+ * the first transaction is mined)
+ * From MonolithDAO Token.sol
+ * @param _spender The address which will spend the funds.
+ * @param _subtractedValue The amount of tokens to decrease the allowance by.
+ */
+ function decreaseApproval(address _spender, uint256 _subtractedValue)
+ public
+ returns (bool) {
+ uint256 oldValue = allowed[msg.sender][_spender];
+ if (_subtractedValue >= oldValue) {
+ allowed[msg.sender][_spender] = 0;
+ }
+ else {
+ allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
+ }
+ emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
+ return true;
+ }
+
+
+ /**
+ * @dev Total number of tokens in existence
+ */
+ function totalSupply() public view returns (uint256) {
+ return supply;
+ }
+
+ /**
+ * @dev Gets the balance of the specified address.
+ * @param _owner The address to query the the balance of.
+ * @return An uint256 representing the amount owned by the passed address.
+ */
+ function balanceOf(address _owner) public view returns (uint256) {
+ return balances[_owner];
+ }
+
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| BurnableToken.sol | +100% | +42/42 | +100% | +8/8 | +100% | +11/11 | +100% | +42/42 | +|
| DividendToken.sol | +95.83% | +23/24 | +100% | +4/4 | +90.91% | +10/11 | +96.55% | +28/29 | +|
| DividendTokenERC20.sol | +100% | +33/33 | +83.33% | +10/12 | +100% | +11/11 | +100% | +37/37 | +|
| GovernedToken.sol | +70% | +7/10 | +25% | +1/4 | +75% | +3/4 | +58.33% | +7/12 | +|
| GovernedTokenERC20.sol | +0% | +0/10 | +0% | +0/4 | +0% | +0/4 | +0% | +0/12 | +|
| MintableToken.sol | +100% | +13/13 | +100% | +2/2 | +100% | +5/5 | +100% | +14/14 | +|
| StandardToken.sol | +100% | +29/29 | +100% | +12/12 | +100% | +8/8 | +100% | +29/29 | +