mirror of
https://github.com/status-im/liquid-funding.git
synced 2025-01-12 20:44:43 +00:00
553 lines
21 KiB
Solidity
553 lines
21 KiB
Solidity
pragma solidity ^0.4.11;
|
|
/*
|
|
Copyright 2017, Jordi Baylina
|
|
Contributor: Adrià Massanet <adria@codecontext.io>
|
|
|
|
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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import "./ILiquidPledgingPlugin.sol";
|
|
import "../node_modules/giveth-common-contracts/contracts/Owned.sol";
|
|
|
|
/// @dev `Vault` serves as an interface to allow the `LiquidPledgingBase`
|
|
/// contract to interface with a `Vault` 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. This function mostly handles the data structures
|
|
/// and basic CRUD methods for liquid pledging.
|
|
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 } // TODO name change Pledged
|
|
|
|
/// @notice This struct defines the details of each the PledgeAdmin, these
|
|
/// PledgeAdmins can own pledges and act as delegates
|
|
struct PledgeAdmin { // TODO name change PledgeAdmin
|
|
PledgeAdminType adminType; // Giver, Delegate or Project
|
|
address addr; // account or contract address for admin
|
|
string name;
|
|
string url;
|
|
uint64 commitTime; // In seconds, used for Givers' & Delegates' vetos
|
|
uint64 parentProject; // Only for projects
|
|
bool canceled; //Always false except for canceled projects
|
|
// if the plugin is 0x0 then nothing happens if its a contract address
|
|
// than that smart contract is called via the milestone contract
|
|
ILiquidPledgingPlugin plugin;
|
|
}
|
|
|
|
struct Pledge {
|
|
uint amount;
|
|
uint64 owner; // PledgeAdmin
|
|
uint64[] delegationChain; // list of index numbers
|
|
// TODO change the name only used for when delegates are
|
|
// pre-committing to a project
|
|
uint64 intendedProject;
|
|
// When the intendedProject will become the owner
|
|
uint64 commitTime;
|
|
// this points to the Pledge[] index that the Pledge was derived from
|
|
uint64 oldPledge;
|
|
PaymentState paymentState;
|
|
}
|
|
|
|
Pledge[] pledges;
|
|
PledgeAdmin[] admins; //The list of pledgeAdmins 0 means there is no admin
|
|
LPVault public vault;
|
|
|
|
// this mapping allows you to search for a specific pledge's
|
|
// index number by the hash of that pledge
|
|
mapping (bytes32 => uint64) hPledge2idx;//TODO Fix typo
|
|
mapping (bytes32 => bool) pluginWhitelist;
|
|
|
|
bool public usePluginWhitelist = true;
|
|
|
|
|
|
/////
|
|
// Modifiers
|
|
/////
|
|
|
|
/// @notice basic method to restrict a function to only the current vault
|
|
modifier onlyVault() {
|
|
require(msg.sender == address(vault));
|
|
_;
|
|
}
|
|
|
|
|
|
//////
|
|
// Constructor
|
|
//////
|
|
|
|
/// @notice The Constructor creates the `LiquidPledgingBase`
|
|
/// on the blockchain
|
|
/// @param _vault The vault where ETH backing this pledge 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);
|
|
}
|
|
|
|
|
|
///////
|
|
// Admin functions
|
|
//////
|
|
|
|
/// @notice `addGiver` Creates a giver and adds them to the list of admins.
|
|
/// @param name This is the name used to identify the giver.
|
|
/// @param url This is a link to the givers profile or a representative site.
|
|
/// @param commitTime Set the default commit time period for this giver.
|
|
/// @param plugin This is givers liquid pledge plugin allowing for
|
|
/// extended functionality.
|
|
function addGiver(
|
|
string name,
|
|
string url,
|
|
uint64 commitTime,
|
|
ILiquidPledgingPlugin plugin
|
|
) returns (uint64 idGiver) {
|
|
require(isValidPlugin(plugin));
|
|
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 `updateGiver` allows for basic update operation to change the address,
|
|
/// name or commitTime associated with a specific giver.
|
|
/// @param idGiver This is the internal ID used to specify the admin lookup
|
|
/// that coresponds to the giver.
|
|
/// @param newAddr This parameter specifies an address to change the given
|
|
/// correspondancec between the giver's internal ID and an external address.
|
|
/// @param newName This is the name used to identify the giver.
|
|
/// @param newUrl This is a link to the givers profile or a representative site.
|
|
/// @param newCommitTime Set the default commit time period for this giver.
|
|
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 originate this tx
|
|
giver.addr = newAddr;
|
|
giver.name = newName;
|
|
giver.url = newUrl;
|
|
giver.commitTime = newCommitTime;
|
|
GiverUpdated(idGiver);
|
|
}
|
|
|
|
event GiverUpdated(uint64 indexed idGiver);
|
|
|
|
/// @notice `addDelegate` Creates a delegate and adds them to the list of admins.
|
|
/// @param name This is the name used to identify the delegate.
|
|
/// @param url This is a link to the delegates profile or a representative site.
|
|
/// @param commitTime Set the default commit time period for this delegate.
|
|
/// @param plugin This is givers liquid pledge plugin allowing for extended functionality.
|
|
function addDelegate(
|
|
string name,
|
|
string url,
|
|
uint64 commitTime,
|
|
ILiquidPledgingPlugin plugin
|
|
) returns (uint64 idxDelegate) { //TODO return index number
|
|
require(isValidPlugin(plugin));
|
|
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 `updateDelegate` allows for basic update operation to change the address,
|
|
/// name or commitTime associated with a specific delegate.
|
|
/// @param idxDelegate This is the internal ID used to specify the admin lookup
|
|
/// that coresponds to the delegate.
|
|
/// @param newAddr This parameter specifies an address to change the given
|
|
/// correspondancec between the giver's internal ID and an external address.
|
|
/// @param newName This is the name used to identify the delegate.
|
|
/// @param newUrl This is a link to the delegates profile or a representative site.
|
|
/// @param newCommitTime Set the default commit time period for this giver.
|
|
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);
|
|
delegate.addr = newAddr;
|
|
delegate.name = newName;
|
|
delegate.url = newUrl;
|
|
delegate.commitTime = newCommitTime;
|
|
DelegateUpdated(idxDelegate);
|
|
}
|
|
|
|
event DelegateUpdated(uint64 indexed idxDelegate);
|
|
|
|
/// @notice `addProject` Creates a project and adds it to the list of admins.
|
|
/// @param name This is the name used to identify the project.
|
|
/// @param url This is a link to the projects profile or a representative site.
|
|
/// @param projectAdmin This is the projects admin. This should be a trusted individual.
|
|
/// @param parentProject If this project has a parent project or a project it's
|
|
/// derived from use this parameter to supply it.
|
|
/// @param commitTime Set the default commit time period for this project.
|
|
/// @param plugin This is the projects liquid pledge plugin allowing for extended functionality.
|
|
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 `updateProject` allows for basic update operation to change the address,
|
|
/// name or commitTime associated with a specific project.
|
|
/// @param idProject This is the internal ID used to specify the admin lookup
|
|
/// that coresponds to the project.
|
|
/// @param newAddr This parameter specifies an address to change the given
|
|
/// correspondance between the project's internal ID and an external address.
|
|
/// @param newName This is the name used to identify the project.
|
|
/// @param newUrl This is a link to the projects profile or a representative site.
|
|
/// @param newCommitTime Set the default commit time period for this 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 `numberOfPledges` is a constant getter that simply returns
|
|
/// the number of pledges.
|
|
function numberOfPledges() constant returns (uint) {
|
|
return pledges.length - 1;
|
|
}
|
|
|
|
/// @notice `getPledge` is a constant getter that simply returns
|
|
/// the amount, owner, the number of delegates, the intended project,
|
|
/// the current commit time and the previous pledge attached to a specific pledge.
|
|
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 `getPledgeDelegate` returns a single delegate given the pledge ID
|
|
/// and the delegate ID.
|
|
/// @param idPledge The ID internally representing the pledge.
|
|
/// @param idxDelegate The ID internally representing the delegate.
|
|
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 `numberOfPledgeAdmins` is a constant getter that simply returns
|
|
/// the number of admins (Givers, Delegates and Projects are all "admins").
|
|
function numberOfPledgeAdmins() constant returns(uint) {
|
|
return admins.length - 1;
|
|
}
|
|
|
|
/// @notice `getPledgeAdmin` is a constant getter that simply returns
|
|
/// the address, name, url, the current commit time and the previous
|
|
/// the parentProject, whether the project has been cancelled
|
|
/// and the projects plugin for a specific project.
|
|
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 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; this creates a Pledge with an initial amount of 0 if one is not
|
|
/// created already. Otherwise
|
|
/// @param owner The owner of the pledge being looked up.
|
|
/// @param delegationChain The array of all delegates.
|
|
/// @param intendedProject The intended project is the project this pledge will Fund.
|
|
/// @param oldPledge This value is used to store the pledge the current pledge
|
|
/// is "coming from."
|
|
/// @param paid Based on the payment state this shows whether the pledge has been paid.
|
|
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 `findAdmin` is a basic getter to return a
|
|
/// specific admin (giver, delegate, or project)
|
|
/// @param idAdmin The admin ID to lookup.
|
|
function findAdmin(uint64 idAdmin) internal returns (PledgeAdmin storage) {
|
|
require(idAdmin < admins.length);
|
|
return admins[idAdmin];
|
|
}
|
|
|
|
/// @notice `findPledge` is a basic getter to return a
|
|
/// specific pledge
|
|
/// @param idPledge The admin ID to pledge.
|
|
function findPledge(uint64 idPledge) internal returns (Pledge storage) {
|
|
require(idPledge < pledges.length);
|
|
return pledges[idPledge];
|
|
}
|
|
|
|
// a constant for the case that a delegate is requested that is not a delegate in the system
|
|
uint64 constant NOTFOUND = 0xFFFFFFFFFFFFFFFF;
|
|
|
|
/// @notice `getDelegateIdx` is a helper function that searches the delegationChain
|
|
/// for a specific delegate and level of delegation returns their idx in the
|
|
/// delegation chain which reflect their level of authority. Returns MAX uint64
|
|
/// if no delegate is found.
|
|
/// @param n The pledge that will be searched.
|
|
/// @param idxDelegate The internal ID of the delegate that's searched for.
|
|
function getDelegateIdx(Pledge n, uint64 idxDelegate) internal returns(uint64) {
|
|
for (uint i=0; i<n.delegationChain.length; i++) {
|
|
if (n.delegationChain[i] == idxDelegate) return uint64(i);
|
|
}
|
|
return NOTFOUND;
|
|
}
|
|
|
|
/// @notice `getPledgeLevel` is a helper function that returns the pledge "depth"
|
|
/// which can be used to check that transfers between Projects
|
|
/// not violate MAX_INTERPROJECT_LEVEL
|
|
/// @param n The pledge that will be searched.
|
|
function getPledgeLevel(Pledge n) internal returns(uint) {
|
|
if (n.oldPledge == 0) return 0; //changed
|
|
Pledge storage oldN = findPledge(n.oldPledge);
|
|
return getPledgeLevel(oldN) + 1;
|
|
}
|
|
|
|
/// @notice `maxCommitTime` is a helper function that returns the maximum
|
|
/// commit time of the owner and all the delegates.
|
|
/// @param n The pledge that will be searched.
|
|
function maxCommitTime(Pledge n) internal returns(uint commitTime) {
|
|
PledgeAdmin storage m = findAdmin(n.owner);
|
|
commitTime = m.commitTime;
|
|
|
|
for (uint i=0; i<n.delegationChain.length; i++) {
|
|
m = findAdmin(n.delegationChain[i]);
|
|
if (m.commitTime > commitTime) commitTime = m.commitTime;
|
|
}
|
|
}
|
|
|
|
/// @notice `getProjectLevel` is a helper function that returns the project
|
|
/// level which can be used to check that there are not too many Projects
|
|
/// that violate MAX_SUBCAMPAIGNS_LEVEL.
|
|
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 `isProjectCanceled` is a basic helper function to check if
|
|
/// a project has been cancelled.
|
|
/// @param projectId The internal id of the project to lookup.
|
|
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 `getOldestPledgeNotCanceled` is a helper function to get the oldest pledge
|
|
/// that hasn't been cancelled recursively.
|
|
/// @param idPledge The starting place to lookup the pledges from
|
|
function getOldestPledgeNotCanceled(uint64 idPledge) internal constant returns(uint64) { //todo rename
|
|
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 `checkAdminOwner` is a helper function designed to throw
|
|
/// an error code if the user is not an admin. As PledgeAdmin is an
|
|
/// an internal structure this basically works like a modifier check
|
|
/// would however using internal data.
|
|
/// @dev Looking into whether this can be done with a modifier would be good
|
|
/// @param m A PledgeAdmin structure object.
|
|
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);
|
|
}
|
|
}
|