//File: contracts/ILiquidPledgingPlugin.sol pragma solidity ^0.4.11; /* Copyright 2017, Jordi Baylina Contributor: Adrià Massanet This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /// @dev `ILiquidPledgingPlugin` is the basic interface for any /// liquid pledging plugin contract ILiquidPledgingPlugin { /// @notice Plugins are used (much like web hooks) to initiate an action /// upon any donation, delegation, or transfer; this is an optional feature /// and allows for extreme customization of the contract. This function /// implements any action that should be initiated before a transfer. /// @param pledgeManager The admin or current manager of the pledge /// @param pledgeFrom This is the Id from which value will be transfered. /// @param pledgeTo This is the Id that value will be transfered to. /// @param context The situation that is triggering the plugin: /// 0 -> Plugin for the owner transferring pledge to another party /// 1 -> Plugin for the first delegate transferring pledge to another party /// 2 -> Plugin for the second delegate transferring pledge to another party /// ... /// 255 -> Plugin for the intendedProject transferring pledge to another party /// /// 256 -> Plugin for the owner receiving pledge to another party /// 257 -> Plugin for the first delegate receiving pledge to another party /// 258 -> Plugin for the second delegate receiving pledge to another party /// ... /// 511 -> Plugin for the intendedProject receiving pledge to another party /// @param amount The amount of value that will be transfered. function beforeTransfer( uint64 pledgeManager, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount ) returns (uint maxAllowed); /// @notice Plugins are used (much like web hooks) to initiate an action /// upon any donation, delegation, or transfer; this is an optional feature /// and allows for extreme customization of the contract. This function /// implements any action that should be initiated after a transfer. /// @param pledgeManager The admin or current manager of the pledge /// @param pledgeFrom This is the Id from which value will be transfered. /// @param pledgeTo This is the Id that value will be transfered to. /// @param context The situation that is triggering the plugin: /// 0 -> Plugin for the owner transferring pledge to another party /// 1 -> Plugin for the first delegate transferring pledge to another party /// 2 -> Plugin for the second delegate transferring pledge to another party /// ... /// 255 -> Plugin for the intendedProject transferring pledge to another party /// /// 256 -> Plugin for the owner receiving pledge to another party /// 257 -> Plugin for the first delegate receiving pledge to another party /// 258 -> Plugin for the second delegate receiving pledge to another party /// ... /// 511 -> Plugin for the intendedProject receiving pledge to another party /// @param amount The amount of value that will be transfered. function afterTransfer( uint64 pledgeManager, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount ); } //File: node_modules/giveth-common-contracts/contracts/Owned.sol pragma solidity ^0.4.15; /// @title Owned /// @author Adrià Massanet /// @notice The Owned contract has an owner address, and provides basic /// authorization control functions, this simplifies & the implementation of /// user permissions; this contract has three work flows for a change in /// ownership, the first requires the new owner to validate that they have the /// ability to accept ownership, the second allows the ownership to be /// directly transfered without requiring acceptance, and the third allows for /// the ownership to be removed to allow for decentralization contract Owned { address public owner; address public newOwnerCandidate; event OwnershipRequested(address indexed by, address indexed to); event OwnershipTransferred(address indexed from, address indexed to); event OwnershipRemoved(); /// @dev The constructor sets the `msg.sender` as the`owner` of the contract function Owned() public { owner = msg.sender; } /// @dev `owner` is the only address that can call a function with this /// modifier modifier onlyOwner() { require (msg.sender == owner); _; } /// @dev In this 1st option for ownership transfer `proposeOwnership()` must /// be called first by the current `owner` then `acceptOwnership()` must be /// called by the `newOwnerCandidate` /// @notice `onlyOwner` Proposes to transfer control of the contract to a /// new owner /// @param _newOwnerCandidate The address being proposed as the new owner function proposeOwnership(address _newOwnerCandidate) public onlyOwner { newOwnerCandidate = _newOwnerCandidate; OwnershipRequested(msg.sender, newOwnerCandidate); } /// @notice Can only be called by the `newOwnerCandidate`, accepts the /// transfer of ownership function acceptOwnership() public { require(msg.sender == newOwnerCandidate); address oldOwner = owner; owner = newOwnerCandidate; newOwnerCandidate = 0x0; OwnershipTransferred(oldOwner, owner); } /// @dev In this 2nd option for ownership transfer `changeOwnership()` can /// be called and it will immediately assign ownership to the `newOwner` /// @notice `owner` can step down and assign some other address to this role /// @param _newOwner The address of the new owner function changeOwnership(address _newOwner) public onlyOwner { require(_newOwner != 0x0); address oldOwner = owner; owner = _newOwner; newOwnerCandidate = 0x0; OwnershipTransferred(oldOwner, owner); } /// @dev In this 3rd option for ownership transfer `removeOwnership()` can /// be called and it will immediately assign ownership to the 0x0 address; /// it requires a 0xdece be input as a parameter to prevent accidental use /// @notice Decentralizes the contract, this operation cannot be undone /// @param _dac `0xdac` has to be entered for this function to work function removeOwnership(address _dac) public onlyOwner { require(_dac == 0xdac); owner = 0x0; newOwnerCandidate = 0x0; OwnershipRemoved(); } } //File: contracts/LiquidPledgingBase.sol pragma solidity ^0.4.11; /* Copyright 2017, Jordi Baylina Contributor: Adrià Massanet This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /// @dev `LPVault` serves as an interface to allow the `LiquidPledgingBase` /// contract to interface with a `LPVault` contract contract LPVault { function authorizePayment(bytes32 _ref, address _dest, uint _amount); function () payable; } /// @dev `LiquidPledgingBase` is the base level contract used to carry out /// liquid pledging's most basic functions, mostly handling and searching the /// data structures contract LiquidPledgingBase is Owned { // Limits inserted to prevent large loops that could prevent canceling uint constant MAX_DELEGATES = 20; uint constant MAX_SUBPROJECT_LEVEL = 20; uint constant MAX_INTERPROJECT_LEVEL = 20; enum PledgeAdminType { Giver, Delegate, Project } enum PaymentState { Pledged, Paying, Paid } /// @dev This struct defines the details of the `PledgeAdmin` which are /// Referenced by their id and can own pledges and act as delegates struct PledgeAdmin { PledgeAdminType adminType; // Giver, Delegate or Project address addr; // Account or contract address for admin string name; string url; // Can be IPFS hash uint64 commitTime; // In seconds, used for Givers' & Delegates' vetos uint64 parentProject; // Only for projects bool canceled; //Always false except for canceled projects /// @dev if the plugin is 0x0 then nothing happens, if its an address // than that smart contract is called when appropriate ILiquidPledgingPlugin plugin; } struct Pledge { uint amount; uint64 owner; // PledgeAdmin uint64[] delegationChain; // List of delegates in order of authority uint64 intendedProject; // Used when delegates are sending to projects uint64 commitTime; // When the intendedProject will become the owner uint64 oldPledge; // Points to the id that this Pledge was derived from PaymentState paymentState; // Pledged, Paying, Paid } Pledge[] pledges; PledgeAdmin[] admins; //The list of pledgeAdmins 0 means there is no admin LPVault public vault; /// @dev this mapping allows you to search for a specific pledge's /// index number by the hash of that pledge mapping (bytes32 => uint64) hPledge2idx; mapping (bytes32 => bool) pluginWhitelist; bool public usePluginWhitelist = true; ///////////// // Modifiers ///////////// /// @dev The `vault`is the only addresses that can call a function with this /// modifier modifier onlyVault() { require(msg.sender == address(vault)); _; } /////////////// // Constructor /////////////// /// @notice The Constructor creates `LiquidPledgingBase` on the blockchain /// @param _vault The vault where the ETH backing the pledges is stored function LiquidPledgingBase(address _vault) { admins.length = 1; // we reserve the 0 admin pledges.length = 1; // we reserve the 0 pledge vault = LPVault(_vault); // Assigns the specified vault } ///////////////////////// // PledgeAdmin functions ///////////////////////// /// @notice Creates a Giver Admin with the `msg.sender` as the Admin address /// @param name The name used to identify the Giver /// @param url The link to the Giver's profile often an IPFS hash /// @param commitTime The length of time in seconds the Giver has to /// veto when the Giver's delegates Pledge funds to a project /// @param plugin This is Giver's liquid pledge plugin allowing for /// extended functionality /// @return idGiver The id number used to reference this Admin function addGiver( string name, string url, uint64 commitTime, ILiquidPledgingPlugin plugin ) returns (uint64 idGiver) { require(isValidPlugin(plugin)); // Plugin check idGiver = uint64(admins.length); admins.push(PledgeAdmin( PledgeAdminType.Giver, msg.sender, name, url, commitTime, 0, false, plugin)); GiverAdded(idGiver); } event GiverAdded(uint64 indexed idGiver); /// @notice Updates a Giver's info to change the address, name, url, or /// commitTime, it cannot be used to change a plugin, and it must be called /// by the current address of the Giver /// @param idGiver This is the Admin id number used to specify the Giver /// @param newAddr The new address that represents this Giver /// @param newName The new name used to identify the Giver /// @param newUrl The new link to the Giver's profile often an IPFS hash /// @param newCommitTime Sets the length of time in seconds the Giver has to /// veto when the Giver's delegates Pledge funds to a project function updateGiver( uint64 idGiver, address newAddr, string newName, string newUrl, uint64 newCommitTime) { PledgeAdmin storage giver = findAdmin(idGiver); require(giver.adminType == PledgeAdminType.Giver); // Must be a Giver require(giver.addr == msg.sender); // Current addr had to send this tx giver.addr = newAddr; giver.name = newName; giver.url = newUrl; giver.commitTime = newCommitTime; GiverUpdated(idGiver); } event GiverUpdated(uint64 indexed idGiver); /// @notice Creates a Delegate Admin with the `msg.sender` as the Admin addr /// @param name The name used to identify the Delegate /// @param url The link to the Delegate's profile often an IPFS hash /// @param commitTime Sets the length of time in seconds the Delegate has to /// veto when the Delegate delegates to another Delegate and they pledge /// those funds to a project /// @param plugin This is Delegate's liquid pledge plugin allowing for /// extended functionality /// @return idxDelegate The id number used to reference this Delegate within /// the admins array function addDelegate( string name, string url, uint64 commitTime, ILiquidPledgingPlugin plugin ) returns (uint64 idxDelegate) { require(isValidPlugin(plugin)); // Plugin check idxDelegate = uint64(admins.length); admins.push(PledgeAdmin( PledgeAdminType.Delegate, msg.sender, name, url, commitTime, 0, false, plugin)); DelegateAdded(idxDelegate); } event DelegateAdded(uint64 indexed idxDelegate); /// @notice Updates a Delegate's info to change the address, name, url, or /// commitTime, it cannot be used to change a plugin, and it must be called /// by the current address of the Delegate /// @param idxDelegate The Admin id number used to specify the Delegate /// @param newAddr The new address that represents this Delegate /// @param newName The new name used to identify the Delegate /// @param newUrl The new link to the Delegate's profile often an IPFS hash /// @param newCommitTime Sets the length of time in seconds the Delegate has /// to veto when the Delegate delegates to a Delegate and they pledge those /// funds to a project function updateDelegate( uint64 idxDelegate, address newAddr, string newName, string newUrl, uint64 newCommitTime) { PledgeAdmin storage delegate = findAdmin(idxDelegate); require(delegate.adminType == PledgeAdminType.Delegate); require(delegate.addr == msg.sender);// Current addr had to send this tx delegate.addr = newAddr; delegate.name = newName; delegate.url = newUrl; delegate.commitTime = newCommitTime; DelegateUpdated(idxDelegate); } event DelegateUpdated(uint64 indexed idxDelegate); /// @notice Creates a Project Admin with the `msg.sender` as the Admin addr /// @param name The name used to identify the Project /// @param url The link to the Project's profile often an IPFS hash /// @param projectAdmin The address for the trusted project manager /// @param parentProject The Admin id number for the parent Campaign or 0 if /// there is no parentProject /// @param commitTime Sets the length of time in seconds the Project has to /// veto when the Project delegates to another Delegate and they pledge /// those funds to a project /// @param plugin This is Project's liquid pledge plugin allowing for /// extended functionality /// @return idProject The id number used to reference this Admin function addProject( string name, string url, address projectAdmin, uint64 parentProject, uint64 commitTime, ILiquidPledgingPlugin plugin ) returns (uint64 idProject) { require(isValidPlugin(plugin)); if (parentProject != 0) { PledgeAdmin storage pa = findAdmin(parentProject); require(pa.adminType == PledgeAdminType.Project); require(getProjectLevel(pa) < MAX_SUBPROJECT_LEVEL); } idProject = uint64(admins.length); admins.push(PledgeAdmin( PledgeAdminType.Project, projectAdmin, name, url, commitTime, parentProject, false, plugin)); ProjectAdded(idProject); } event ProjectAdded(uint64 indexed idProject); /// @notice Updates a Project's info to change the address, name, url, or /// commitTime, it cannot be used to change a plugin or a parentProject, /// and it must be called by the current address of the Project /// @param idProject The Admin id number used to specify the Project /// @param newAddr The new address that represents this Project /// @param newName The new name used to identify the Project /// @param newUrl The new link to the Project's profile often an IPFS hash /// @param newCommitTime Sets the length of time in seconds the Project has /// to veto when the Project delegates to a Delegate and they pledge those /// funds to a project function updateProject( uint64 idProject, address newAddr, string newName, string newUrl, uint64 newCommitTime) { PledgeAdmin storage project = findAdmin(idProject); require(project.adminType == PledgeAdminType.Project); require(project.addr == msg.sender); project.addr = newAddr; project.name = newName; project.url = newUrl; project.commitTime = newCommitTime; ProjectUpdated(idProject); } event ProjectUpdated(uint64 indexed idAdmin); ////////// // Public constant functions ////////// /// @notice A constant getter that returns the total number of pledges /// @return The total number of Pledges in the system function numberOfPledges() constant returns (uint) { return pledges.length - 1; } /// @notice A getter that returns the details of the specified pledge /// @param idPledge the id number of the pledge being queried /// @return the amount, owner, the number of delegates (but not the actual /// delegates, the intendedProject (if any), the current commit time and /// the previous pledge this pledge was derived from function getPledge(uint64 idPledge) constant returns( uint amount, uint64 owner, uint64 nDelegates, uint64 intendedProject, uint64 commitTime, uint64 oldPledge, PaymentState paymentState ) { Pledge storage n = findPledge(idPledge); amount = n.amount; owner = n.owner; nDelegates = uint64(n.delegationChain.length); intendedProject = n.intendedProject; commitTime = n.commitTime; oldPledge = n.oldPledge; paymentState = n.paymentState; } /// @notice Getter to find Delegate w/ the Pledge ID & the Delegate index /// @param idPledge The id number representing the pledge being queried /// @param idxDelegate The index number for the delegate in this Pledge function getPledgeDelegate(uint64 idPledge, uint idxDelegate) constant returns( uint64 idDelegate, address addr, string name ) { Pledge storage n = findPledge(idPledge); idDelegate = n.delegationChain[idxDelegate - 1]; PledgeAdmin storage delegate = findAdmin(idDelegate); addr = delegate.addr; name = delegate.name; } /// @notice A constant getter used to check how many total Admins exist /// @return The total number of admins (Givers, Delegates and Projects) . function numberOfPledgeAdmins() constant returns(uint) { return admins.length - 1; } /// @notice A constant getter to check the details of a specified Admin /// @return addr Account or contract address for admin /// @return name Name of the pledgeAdmin /// @return url The link to the Project's profile often an IPFS hash /// @return commitTime The length of time in seconds the Admin has to veto /// when the Admin delegates to a Delegate and that Delegate pledges those /// funds to a project /// @return parentProject The Admin id number for the parent Campaign or 0 /// if there is no parentProject /// @return canceled 0 for Delegates & Givers, true if a Project has been /// canceled /// @return plugin This is Project's liquidPledging plugin allowing for /// extended functionality function getPledgeAdmin(uint64 idAdmin) constant returns ( PledgeAdminType adminType, address addr, string name, string url, uint64 commitTime, uint64 parentProject, bool canceled, address plugin) { PledgeAdmin storage m = findAdmin(idAdmin); adminType = m.adminType; addr = m.addr; name = m.name; url = m.url; commitTime = m.commitTime; parentProject = m.parentProject; canceled = m.canceled; plugin = address(m.plugin); } //////// // Private methods /////// /// @notice This creates a Pledge with an initial amount of 0 if one is not /// created already; otherwise it finds the pledge with the specified /// attributes; all pledges technically exist, if the pledge hasn't been /// created in this system yet it simply isn't in the hash array /// hPledge2idx[] yet /// @param owner The owner of the pledge being looked up /// @param delegationChain The list of delegates in order of authority /// @param intendedProject The project this pledge will Fund after the /// commitTime has passed /// @param commitTime The length of time in seconds the Giver has to /// veto when the Giver's delegates Pledge funds to a project /// @param oldPledge This value is used to store the pledge the current /// pledge was came from, and in the case a Project is canceled, the Pledge /// will revert back to it's previous state /// @param paid The payment state: Pledged, Paying, or Paid /// @return The hPledge2idx index number function findOrCreatePledge( uint64 owner, uint64[] delegationChain, uint64 intendedProject, uint64 commitTime, uint64 oldPledge, PaymentState paid ) internal returns (uint64) { bytes32 hPledge = sha3( owner, delegationChain, intendedProject, commitTime, oldPledge, paid); uint64 idx = hPledge2idx[hPledge]; if (idx > 0) return idx; idx = uint64(pledges.length); hPledge2idx[hPledge] = idx; pledges.push(Pledge( 0, owner, delegationChain, intendedProject, commitTime, oldPledge, paid)); return idx; } /// @notice A getter to look up a Admin's details /// @param idAdmin The id for the Admin to lookup /// @return The PledgeAdmin struct for the specified Admin function findAdmin(uint64 idAdmin) internal returns (PledgeAdmin storage) { require(idAdmin < admins.length); return admins[idAdmin]; } /// @notice A getter to look up a Pledge's details /// @param idPledge The id for the Pledge to lookup /// @return The PledgeA struct for the specified Pledge function findPledge(uint64 idPledge) internal returns (Pledge storage) { require(idPledge < pledges.length); return pledges[idPledge]; } // a constant for when a delegate is requested that is not in the system uint64 constant NOTFOUND = 0xFFFFFFFFFFFFFFFF; /// @notice A getter that searches the delegationChain for the level of /// authority a specific delegate has within a Pledge /// @param n The Pledge that will be searched /// @param idxDelegate The specified delegate that's searched for /// @return How many Delegates have more authority than the specified /// delegate; if the delegate is not in the delegationChain it will return /// `0xFFFFFFFFFFFFFFFF` function getDelegateIdx(Pledge n, uint64 idxDelegate) internal returns(uint64) { for (uint i=0; i commitTime) commitTime = m.commitTime; } } /// @notice A getter to find the level of authority a specific Project has /// using a self-referential loop /// @param m The Project being queried /// @return The level of authority a specific Project has function getProjectLevel(PledgeAdmin m) internal returns(uint) { assert(m.adminType == PledgeAdminType.Project); if (m.parentProject == 0) return(1); PledgeAdmin storage parentNM = findAdmin(m.parentProject); return getProjectLevel(parentNM); } /// @notice A getter to find if a specified Project has been canceled /// @param projectId The Admin id number used to specify the Project /// @return True if the Project has been canceled function isProjectCanceled(uint64 projectId) constant returns (bool) { PledgeAdmin storage m = findAdmin(projectId); if (m.adminType == PledgeAdminType.Giver) return false; assert(m.adminType == PledgeAdminType.Project); if (m.canceled) return true; if (m.parentProject == 0) return false; return isProjectCanceled(m.parentProject); } /// @notice A getter to find the oldest pledge that hasn't been canceled /// @param idPledge The starting place to lookup the pledges /// @return The oldest idPledge that hasn't been canceled (DUH!) function getOldestPledgeNotCanceled(uint64 idPledge ) internal constant returns(uint64) { if (idPledge == 0) return 0; Pledge storage n = findPledge(idPledge); PledgeAdmin storage admin = findAdmin(n.owner); if (admin.adminType == PledgeAdminType.Giver) return idPledge; assert(admin.adminType == PledgeAdminType.Project); if (!isProjectCanceled(n.owner)) return idPledge; return getOldestPledgeNotCanceled(n.oldPledge); } /// @notice A check to see if the msg.sender is the owner or the /// plugin contract for a specific Admin /// @param m The Admin being checked function checkAdminOwner(PledgeAdmin m) internal constant { require((msg.sender == m.addr) || (msg.sender == address(m.plugin))); } /////////////////////////// // Plugin Whitelist Methods /////////////////////////// function addValidPlugin(bytes32 contractHash) external onlyOwner { pluginWhitelist[contractHash] = true; } function removeValidPlugin(bytes32 contractHash) external onlyOwner { pluginWhitelist[contractHash] = false; } function useWhitelist(bool useWhitelist) external onlyOwner { usePluginWhitelist = useWhitelist; } function isValidPlugin(address addr) public returns(bool) { if (!usePluginWhitelist || addr == 0x0) return true; bytes32 contractHash = getCodeHash(addr); return pluginWhitelist[contractHash]; } function getCodeHash(address addr) public returns(bytes32) { bytes memory o_code; assembly { // retrieve the size of the code, this needs assembly let size := extcodesize(addr) // allocate output byte array - this could also be done without assembly // by using o_code = new bytes(size) o_code := mload(0x40) // new "memory end" including padding mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f)))) // store length in memory mstore(o_code, size) // actually retrieve the code, this needs assembly extcodecopy(addr, add(o_code, 0x20), 0, size) } return keccak256(o_code); } } //File: contracts/LiquidPledging.sol pragma solidity ^0.4.11; /* Copyright 2017, Jordi Baylina Contributor: Adrià Massanet This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ // Contract Imports /// @dev `LiquidPleding` allows for liquid pledging through the use of /// internal id structures and delegate chaining. All basic operations for /// handling liquid pledging are supplied as well as plugin features /// to allow for expanded functionality. contract LiquidPledging is LiquidPledgingBase { ////// // Constructor ////// /// @notice Basic constructor for LiquidPleding, also calls the /// LiquidPledgingBase contract /// @dev This constructor also calls the constructor /// for `LiquidPledgingBase` /// @param _vault The vault where ETH backing this pledge is stored function LiquidPledging(address _vault) LiquidPledgingBase(_vault) { } /// @notice This is how value enters into the system which creates pledges; /// the token of value goes into the vault and the amount in the pledge /// relevant to this Giver without delegates is increased, and a normal /// transfer is done to the idReceiver /// @param idGiver Identifier of the giver thats donating. /// @param idReceiver To whom it's transfered. Can be the same giver, /// another giver, a delegate or a project. function donate(uint64 idGiver, uint64 idReceiver) payable { if (idGiver == 0) { // default to 3 day commitTime idGiver = addGiver("", "", 259200, ILiquidPledgingPlugin(0x0)); } PledgeAdmin storage sender = findAdmin(idGiver); checkAdminOwner(sender); require(sender.adminType == PledgeAdminType.Giver); uint amount = msg.value; require(amount > 0); vault.transfer(amount); // transfers the baseToken to the Vault uint64 idPledge = findOrCreatePledge( idGiver, new uint64[](0), //what is new? 0, 0, 0, PaymentState.Pledged ); Pledge storage nTo = findPledge(idPledge); nTo.amount += amount; Transfer(0, idPledge, amount); transfer(idGiver, idPledge, amount, idReceiver); } /// @notice Moves value between pledges /// @param idSender ID of the giver, delegate or project admin that is /// transferring the funds from Pledge to Pledge; this admin must have /// permissions to move the value /// @param idPledge Id of the pledge that's moving the value /// @param amount Quantity of value that's being moved /// @param idReceiver Destination of the value, can be a giver sending to /// a giver or a delegate, a delegate to another delegate or a project /// to pre-commit it to that project function transfer( uint64 idSender, uint64 idPledge, uint amount, uint64 idReceiver ) { idPledge = normalizePledge(idPledge); Pledge storage n = findPledge(idPledge); PledgeAdmin storage receiver = findAdmin(idReceiver); PledgeAdmin storage sender = findAdmin(idSender); checkAdminOwner(sender); require(n.paymentState == PaymentState.Pledged); // If the sender is the owner if (n.owner == idSender) { if (receiver.adminType == PledgeAdminType.Giver) { transferOwnershipToGiver(idPledge, amount, idReceiver); } else if (receiver.adminType == PledgeAdminType.Project) { transferOwnershipToProject(idPledge, amount, idReceiver); } else if (receiver.adminType == PledgeAdminType.Delegate) { idPledge = undelegate( idPledge, amount, n.delegationChain.length ); appendDelegate(idPledge, amount, idReceiver); } else { assert(false); } return; } // If the sender is a delegate uint senderDIdx = getDelegateIdx(n, idSender); if (senderDIdx != NOTFOUND) { // If the receiver is another giver if (receiver.adminType == PledgeAdminType.Giver) { // Only accept to change to the original giver to // remove all delegates assert(n.owner == idReceiver); undelegate(idPledge, amount, n.delegationChain.length); return; } // If the receiver is another delegate if (receiver.adminType == PledgeAdminType.Delegate) { uint receiverDIdx = getDelegateIdx(n, idReceiver); // If the receiver is not in the delegate list if (receiverDIdx == NOTFOUND) { idPledge = undelegate( idPledge, amount, n.delegationChain.length - senderDIdx - 1 ); appendDelegate(idPledge, amount, idReceiver); // If the receiver is already part of the delegate chain and is // after the sender, then all of the other delegates after the // sender are removed and the receiver is appended at the // end of the delegation chain } else if (receiverDIdx > senderDIdx) { idPledge = undelegate( idPledge, amount, n.delegationChain.length - senderDIdx - 1 ); appendDelegate(idPledge, amount, idReceiver); // If the receiver is already part of the delegate chain and is // before the sender, then the sender and all of the other // delegates after the RECEIVER are removed from the chain, // this is interesting because the delegate is removed from the // delegates that delegated to this delegate. Are there game theory // issues? should this be allowed? } else if (receiverDIdx <= senderDIdx) { undelegate( idPledge, amount, n.delegationChain.length - receiverDIdx - 1 ); } return; } // If the delegate wants to support a project, they remove all // the delegates after them in the chain and choose a project if (receiver.adminType == PledgeAdminType.Project) { idPledge = undelegate( idPledge, amount, n.delegationChain.length - senderDIdx - 1 ); proposeAssignProject(idPledge, amount, idReceiver); return; } } assert(false); // It is not the owner nor any delegate. } /// @notice This method is used to withdraw value from the system. /// This can be used by the givers to avoid committing the donation /// or by project admin to use the Ether. /// @param idPledge Id of the pledge that wants to be withdrawn. /// @param amount Quantity of Ether that wants to be withdrawn. function withdraw(uint64 idPledge, uint amount) { idPledge = normalizePledge(idPledge); Pledge storage n = findPledge(idPledge); require(n.paymentState == PaymentState.Pledged); PledgeAdmin storage owner = findAdmin(n.owner); checkAdminOwner(owner); uint64 idNewPledge = findOrCreatePledge( n.owner, n.delegationChain, 0, 0, n.oldPledge, PaymentState.Paying ); doTransfer(idPledge, idNewPledge, amount); vault.authorizePayment(bytes32(idNewPledge), owner.addr, amount); } /// @notice Method called by the vault to confirm a payment. /// @param idPledge Id of the pledge that wants to be withdrawn. /// @param amount Quantity of Ether that wants to be withdrawn. function confirmPayment(uint64 idPledge, uint amount) onlyVault { Pledge storage n = findPledge(idPledge); require(n.paymentState == PaymentState.Paying); uint64 idNewPledge = findOrCreatePledge( n.owner, n.delegationChain, 0, 0, n.oldPledge, PaymentState.Paid ); doTransfer(idPledge, idNewPledge, amount); } /// @notice Method called by the vault to cancel a payment. /// @param idPledge Id of the pledge that wants to be canceled for withdraw. /// @param amount Quantity of Ether that wants to be rolled back. function cancelPayment(uint64 idPledge, uint amount) onlyVault { Pledge storage n = findPledge(idPledge); require(n.paymentState == PaymentState.Paying); //TODO change to revert // When a payment is canceled, never is assigned to a project. uint64 oldPledge = findOrCreatePledge( n.owner, n.delegationChain, 0, 0, n.oldPledge, PaymentState.Pledged ); oldPledge = normalizePledge(oldPledge); doTransfer(idPledge, oldPledge, amount); } /// @notice Method called to cancel this project. /// @param idProject Id of the projct that wants to be canceled. function cancelProject(uint64 idProject) { PledgeAdmin storage project = findAdmin(idProject); checkAdminOwner(project); project.canceled = true; CancelProject(idProject); } /// @notice Method called to cancel specific pledge. /// @param idPledge Id of the pledge that should be canceled. /// @param amount Quantity of Ether that wants to be rolled back. function cancelPledge(uint64 idPledge, uint amount) { idPledge = normalizePledge(idPledge); Pledge storage n = findPledge(idPledge); require(n.oldPledge != 0); PledgeAdmin storage m = findAdmin(n.owner); checkAdminOwner(m); uint64 oldPledge = getOldestPledgeNotCanceled(n.oldPledge); doTransfer(idPledge, oldPledge, amount); } //////// // Multi pledge methods //////// // @dev This set of functions makes moving a lot of pledges around much more // efficient (saves gas) than calling these functions in series /// Bit mask used for dividing pledge amounts in Multi pledge methods uint constant D64 = 0x10000000000000000; /// @notice `mTransfer` allows for multiple pledges to be transferred /// efficiently /// @param idSender ID of the giver, delegate or project admin that is /// transferring the funds from Pledge to Pledge. This admin must have /// permissions to move the value /// @param pledgesAmounts An array of pledge amounts and IDs which are extrapolated /// using the D64 bitmask /// @param idReceiver Destination of the value, can be a giver sending /// to a giver or a delegate or a delegate to another delegate or a /// project to pre-commit it to that project function mTransfer( uint64 idSender, uint[] pledgesAmounts, uint64 idReceiver ) { for (uint i = 0; i < pledgesAmounts.length; i++ ) { uint64 idPledge = uint64( pledgesAmounts[i] & (D64-1) ); uint amount = pledgesAmounts[i] / D64; transfer(idSender, idPledge, amount, idReceiver); } } /// @notice `mWithdraw` allows for multiple pledges to be /// withdrawn efficiently /// @param pledgesAmounts An array of pledge amounts and IDs which are /// extrapolated using the D64 bitmask function mWithdraw(uint[] pledgesAmounts) { for (uint i = 0; i < pledgesAmounts.length; i++ ) { uint64 idPledge = uint64( pledgesAmounts[i] & (D64-1) ); uint amount = pledgesAmounts[i] / D64; withdraw(idPledge, amount); } } /// @notice `mConfirmPayment` allows for multiple pledges to be confirmed /// efficiently /// @param pledgesAmounts An array of pledge amounts and IDs which are extrapolated /// using the D64 bitmask function mConfirmPayment(uint[] pledgesAmounts) { for (uint i = 0; i < pledgesAmounts.length; i++ ) { uint64 idPledge = uint64( pledgesAmounts[i] & (D64-1) ); uint amount = pledgesAmounts[i] / D64; confirmPayment(idPledge, amount); } } /// @notice `mCancelPayment` allows for multiple pledges to be canceled /// efficiently /// @param pledgesAmounts An array of pledge amounts and IDs which are extrapolated /// using the D64 bitmask function mCancelPayment(uint[] pledgesAmounts) { for (uint i = 0; i < pledgesAmounts.length; i++ ) { uint64 idPledge = uint64( pledgesAmounts[i] & (D64-1) ); uint amount = pledgesAmounts[i] / D64; cancelPayment(idPledge, amount); } } /// @notice `mNormalizePledge` allows for multiple pledges to be /// normalized efficiently /// @param pledges An array of pledge IDs which are extrapolated using /// the D64 bitmask function mNormalizePledge(uint64[] pledges) { for (uint i = 0; i < pledges.length; i++ ) { normalizePledge( pledges[i] ); } } //////// // Private methods /////// /// @notice `transferOwnershipToProject` allows for the transfer of /// ownership to the project, but it can also be called to un-delegate /// everyone by setting one's own id for the idReceiver /// @param idPledge Id of the pledge to be transfered. /// @param amount Quantity of value that's being transfered /// @param idReceiver The new owner of the project (or self to un-delegate) function transferOwnershipToProject( uint64 idPledge, uint amount, uint64 idReceiver ) internal { Pledge storage n = findPledge(idPledge); // Ensure that the pledge is not already at max pledge depth // and the project has not been canceled require(getPledgeLevel(n) < MAX_INTERPROJECT_LEVEL); require(!isProjectCanceled(idReceiver)); uint64 oldPledge = findOrCreatePledge( n.owner, n.delegationChain, 0, 0, n.oldPledge, PaymentState.Pledged ); uint64 toPledge = findOrCreatePledge( idReceiver, // Set the new owner new uint64[](0), // clear the delegation chain 0, 0, oldPledge, PaymentState.Pledged ); doTransfer(idPledge, toPledge, amount); } /// @notice `transferOwnershipToGiver` allows for the transfer of /// value back to the Giver, value is placed in a pledged state /// without being attached to a project, delegation chain, or time line. /// @param idPledge Id of the pledge to be transfered. /// @param amount Quantity of value that's being transfered /// @param idReceiver The new owner of the pledge function transferOwnershipToGiver( uint64 idPledge, uint amount, uint64 idReceiver ) internal { uint64 toPledge = findOrCreatePledge( idReceiver, new uint64[](0), 0, 0, 0, PaymentState.Pledged ); doTransfer(idPledge, toPledge, amount); } /// @notice `appendDelegate` allows for a delegate to be added onto the /// end of the delegate chain for a given Pledge. /// @param idPledge Id of the pledge thats delegate chain will be modified. /// @param amount Quantity of value that's being chained. /// @param idReceiver The delegate to be added at the end of the chain function appendDelegate( uint64 idPledge, uint amount, uint64 idReceiver ) internal { Pledge storage n = findPledge(idPledge); require(n.delegationChain.length < MAX_DELEGATES); uint64[] memory newDelegationChain = new uint64[]( n.delegationChain.length + 1 ); for (uint i = 0; i= amount); nFrom.amount -= amount; nTo.amount += amount; Transfer(from, to, amount); callPlugins(false, from, to, amount); } /// @notice `normalizePledge` does 2 things: /// #1: Checks to make sure that the pledges are correct. Then if /// a pledged project has already been committed, it changes /// the owner to be the proposed project (The UI /// will have to read the commit time and manually do what /// this function does to the pledge for the end user /// at the expiration of the commitTime) /// /// #2: Checks to make sure that if there has been a cancellation in the /// chain of projects, the pledge's owner has been changed /// appropriately. /// /// This function can be called by anybody at anytime on any pledge. /// In general it can be called to force the calls of the affected /// plugins, which also need to be predicted by the UI /// @param idPledge This is the id of the pledge that will be normalized function normalizePledge(uint64 idPledge) returns(uint64) { Pledge storage n = findPledge(idPledge); // Check to make sure this pledge hasn't already been used // or is in the process of being used if (n.paymentState != PaymentState.Pledged) return idPledge; // First send to a project if it's proposed and committed if ((n.intendedProject > 0) && ( getTime() > n.commitTime)) { uint64 oldPledge = findOrCreatePledge( n.owner, n.delegationChain, 0, 0, n.oldPledge, PaymentState.Pledged); uint64 toPledge = findOrCreatePledge( n.intendedProject, new uint64[](0), 0, 0, oldPledge, PaymentState.Pledged); doTransfer(idPledge, toPledge, n.amount); idPledge = toPledge; n = findPledge(idPledge); } toPledge = getOldestPledgeNotCanceled(idPledge);// TODO toPledge is pledge defined if (toPledge != idPledge) { doTransfer(idPledge, toPledge, n.amount); } return toPledge; } ///////////// // Plugins ///////////// /// @notice `callPlugin` is used to trigger the general functions in the /// plugin for any actions needed before and after a transfer happens. /// Specifically what this does in relation to the plugin is something /// that largely depends on the functions of that plugin. This function /// is generally called in pairs, once before, and once after a transfer. /// @param before This toggle determines whether the plugin call is occurring /// before or after a transfer. /// @param adminId This should be the Id of the *trusted* individual /// who has control over this plugin. /// @param fromPledge This is the Id from which value is being transfered. /// @param toPledge This is the Id that value is being transfered to. /// @param context The situation that is triggering the plugin. See plugin /// for a full description of contexts. /// @param amount The amount of value that is being transfered. function callPlugin( bool before, uint64 adminId, uint64 fromPledge, uint64 toPledge, uint64 context, uint amount ) internal returns (uint allowedAmount) { uint newAmount; allowedAmount = amount; PledgeAdmin storage admin = findAdmin(adminId); // Checks admin has a plugin assigned and a non-zero amount is requested if ((address(admin.plugin) != 0) && (allowedAmount > 0)) { // There are two seperate functions called in the plugin. // One is called before the transfer and one after if (before) { newAmount = admin.plugin.beforeTransfer( adminId, fromPledge, toPledge, context, amount ); require(newAmount <= allowedAmount); allowedAmount = newAmount; } else { admin.plugin.afterTransfer( adminId, fromPledge, toPledge, context, amount ); } } } /// @notice `callPluginsPledge` is used to apply plugin calls to /// the delegate chain and the intended project if there is one. /// It does so in either a transferring or receiving context based /// on the `idPledge` and `fromPledge` parameters. /// @param before This toggle determines whether the plugin call is occuring /// before or after a transfer. /// @param idPledge This is the Id of the pledge on which this plugin /// is being called. /// @param fromPledge This is the Id from which value is being transfered. /// @param toPledge This is the Id that value is being transfered to. /// @param amount The amount of value that is being transfered. function callPluginsPledge( bool before, uint64 idPledge, uint64 fromPledge, uint64 toPledge, uint amount ) internal returns (uint allowedAmount) { // Determine if callPlugin is being applied in a receiving // or transferring context uint64 offset = idPledge == fromPledge ? 0 : 256; allowedAmount = amount; Pledge storage n = findPledge(idPledge); // Always call the plugin on the owner allowedAmount = callPlugin( before, n.owner, fromPledge, toPledge, offset, allowedAmount ); // Apply call plugin to all delegates for (uint64 i=0; i 0) { allowedAmount = callPlugin( before, n.intendedProject, fromPledge, toPledge, offset + 255, allowedAmount ); } } /// @notice `callPlugins` calls `callPluginsPledge` once for the transfer /// context and once for the receiving context. The aggregated /// allowed amount is then returned. /// @param before This toggle determines whether the plugin call is occuring /// before or after a transfer. /// @param fromPledge This is the Id from which value is being transfered. /// @param toPledge This is the Id that value is being transfered to. /// @param amount The amount of value that is being transfered. function callPlugins( bool before, uint64 fromPledge, uint64 toPledge, uint amount ) internal returns (uint allowedAmount) { allowedAmount = amount; // Call the pledges plugins in the transfer context allowedAmount = callPluginsPledge( before, fromPledge, fromPledge, toPledge, allowedAmount ); // Call the pledges plugins in the receive context allowedAmount = callPluginsPledge( before, toPledge, fromPledge, toPledge, allowedAmount ); } ///////////// // Test functions ///////////// /// @notice Basic helper function to return the current time function getTime() internal returns (uint) { return now; } // Event Delcerations event Transfer(uint64 indexed from, uint64 indexed to, uint amount); event CancelProject(uint64 indexed idProject); } //File: ./contracts/test/TestSimpleProjectPlugin.sol pragma solidity ^0.4.11; // simple liquidPledging plugin contract for testing whitelist contract TestSimpleProjectPlugin { uint64 public idProject; bool initPending; event BeforeTransfer(uint64 pledgeAdmin, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount); event AfterTransfer(uint64 pledgeAdmin, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount); function TestSimpleProjectPlugin() { require(msg.sender != tx.origin); // Avoids being created directly by mistake. initPending = true; } function init( LiquidPledging liquidPledging, string name, string url, uint64 parentProject ) { require(initPending); idProject = liquidPledging.addProject(name, url, address(this), parentProject, 0, ILiquidPledgingPlugin(this)); initPending = false; } function beforeTransfer( uint64 pledgeAdmin, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount ) external returns (uint maxAllowed) { require(!initPending); BeforeTransfer(pledgeAdmin, pledgeFrom, pledgeTo, context, amount); } function afterTransfer( uint64 pledgeAdmin, uint64 pledgeFrom, uint64 pledgeTo, uint64 context, uint amount ) external { require(!initPending); AfterTransfer(pledgeAdmin, pledgeFrom, pledgeTo, context, amount); } }