2017-06-06 17:40:14 +00:00
|
|
|
pragma solidity ^0.4.11;
|
|
|
|
|
2017-07-13 17:12:45 +00:00
|
|
|
contract Vault {
|
|
|
|
function authorizePayment(bytes32 _ref, address _dest, uint _amount);
|
|
|
|
}
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-06-26 17:54:28 +00:00
|
|
|
contract LiquidPledgingBase {
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-07-13 17:21:53 +00:00
|
|
|
uint constant MAX_DELEGATES = 20;
|
2017-07-09 17:04:02 +00:00
|
|
|
uint constant MAX_SUBPROJECT_LEVEL = 20;
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
enum NoteManagerType { Donor, Delegate, Project }// todo change name
|
|
|
|
enum PaymentState { NotPaid, Paying, Paid }
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
// This struct defines the details of each the NoteManager, these NoteManagers can create
|
|
|
|
struct NoteManager {// change manager
|
2017-06-06 17:40:14 +00:00
|
|
|
NoteManagerType managerType;
|
|
|
|
address addr;
|
|
|
|
string name;
|
2017-07-13 17:21:53 +00:00
|
|
|
uint64 commitTime; // Only used in donors and projects, its the precommitment time
|
2017-06-06 17:40:14 +00:00
|
|
|
address reviewer; // Only for project
|
|
|
|
bool canceled; // Only for project
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Note {
|
|
|
|
uint amount;
|
|
|
|
uint64 owner;
|
2017-07-09 17:04:02 +00:00
|
|
|
uint64[] delegationChain; //index numbers!!!!!
|
|
|
|
uint64 proposedProject; // TODO change the name only used for when delegates are precommiting to a project
|
2017-06-27 11:08:23 +00:00
|
|
|
uint64 commitTime; // At what time the upcoming time will become an owner.
|
2017-07-13 17:21:53 +00:00
|
|
|
uint64 oldNote; // this points to the Note[] index that the Note was derived from
|
2017-06-06 17:40:14 +00:00
|
|
|
PaymentState paymentState;
|
|
|
|
}
|
|
|
|
|
|
|
|
Note[] notes;
|
2017-07-13 17:21:53 +00:00
|
|
|
NoteManager[] managers; // the list of all the note managers 0 is reserved for no manager
|
2017-06-06 17:40:14 +00:00
|
|
|
Vault public vault;
|
|
|
|
|
2017-07-13 17:21:53 +00:00
|
|
|
// this mapping allows you to search for a specific note's index number by the hash of that note
|
|
|
|
mapping (bytes32 => uint64) hNote2ddx;//TODO Fix typo
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
/////
|
|
|
|
// Modifiers
|
|
|
|
/////
|
|
|
|
|
|
|
|
modifier onlyVault() {
|
2017-07-13 17:12:45 +00:00
|
|
|
require(msg.sender == address(vault));
|
2017-06-06 17:40:14 +00:00
|
|
|
_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////
|
|
|
|
// Constructor
|
|
|
|
//////
|
|
|
|
|
|
|
|
function LiquidPledgingBase(address _vault) {
|
2017-07-09 17:04:02 +00:00
|
|
|
managers.length = 1; // we reserve the 0 manager
|
|
|
|
notes.length = 1; // we reserve the 0 note
|
2017-06-06 17:40:14 +00:00
|
|
|
vault = Vault(_vault);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
///////
|
|
|
|
// Managers functions
|
|
|
|
//////
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
function addDonor(string name, uint64 commitTime) {//Todo return idManager
|
2017-06-06 17:40:14 +00:00
|
|
|
managers.push(NoteManager(
|
|
|
|
NoteManagerType.Donor,
|
|
|
|
msg.sender,
|
|
|
|
name,
|
|
|
|
commitTime,
|
|
|
|
0x0,
|
|
|
|
false));
|
|
|
|
|
|
|
|
DonorAdded(uint64(managers.length-1));
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event DonorAdded(uint64 indexed idDonor);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
function updateDonor(
|
|
|
|
uint64 idDonor,
|
|
|
|
address newAddr,
|
|
|
|
string newName,
|
|
|
|
uint64 newCommitTime)
|
|
|
|
{
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage donor = findManager(idDonor);
|
|
|
|
require(donor.managerType == NoteManagerType.Donor);
|
|
|
|
require(donor.addr == msg.sender);
|
2017-06-06 17:40:14 +00:00
|
|
|
donor.addr = newAddr;
|
|
|
|
donor.name = newName;
|
|
|
|
donor.commitTime = newCommitTime;
|
|
|
|
DonorUpdated(idDonor);
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event DonorUpdated(uint64 indexed idDonor);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
function addDelegate(string name) { //TODO return index number
|
2017-06-06 17:40:14 +00:00
|
|
|
managers.push(NoteManager(
|
|
|
|
NoteManagerType.Delegate,
|
|
|
|
msg.sender,
|
|
|
|
name,
|
|
|
|
0,
|
|
|
|
0x0,
|
|
|
|
false));
|
|
|
|
|
|
|
|
DeegateAdded(uint64(managers.length-1));
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event DeegateAdded(uint64 indexed idDelegate);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
function updateDelegate(uint64 idDelegate, address newAddr, string newName) {
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage delegate = findManager(idDelegate);
|
|
|
|
require(delegate.managerType == NoteManagerType.Delegate);
|
|
|
|
require(delegate.addr == msg.sender);
|
2017-06-06 17:40:14 +00:00
|
|
|
delegate.addr = newAddr;
|
|
|
|
delegate.name = newName;
|
|
|
|
DelegateUpdated(idDelegate);
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event DelegateUpdated(uint64 indexed idDelegate);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
function addProject(string name, address reviewer, uint64 commitTime) {
|
|
|
|
managers.push(NoteManager(
|
|
|
|
NoteManagerType.Project,
|
|
|
|
msg.sender,
|
|
|
|
name,
|
|
|
|
commitTime,
|
|
|
|
reviewer,
|
|
|
|
false));
|
|
|
|
|
|
|
|
ProjectAdded(uint64(managers.length-1));
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event ProjectAdded(uint64 indexed idProject);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
function updateProject(uint64 idProject, address newAddr, string newName, uint64 newCommitTime) {
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage project = findManager(idProject);
|
|
|
|
require(project.managerType == NoteManagerType.Project);
|
|
|
|
require(project.addr == msg.sender);
|
2017-06-06 17:40:14 +00:00
|
|
|
project.addr = newAddr;
|
|
|
|
project.name = newName;
|
|
|
|
project.commitTime = newCommitTime;
|
|
|
|
ProjectUpdated(idProject);
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
function updateProjectReviewer(uint64 idProject, address newReviewer) {
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage project = findManager(idProject);
|
|
|
|
require(project.managerType == NoteManagerType.Project);
|
|
|
|
require(project.reviewer == msg.sender);
|
2017-06-06 17:40:14 +00:00
|
|
|
project.reviewer = newReviewer;
|
|
|
|
ProjectUpdated(idProject);
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
event ProjectUpdated(uint64 indexed idManager);
|
2017-06-06 17:40:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
//////////
|
|
|
|
// Public constant functions
|
|
|
|
//////////
|
|
|
|
|
|
|
|
|
|
|
|
function numberOfNotes() constant returns (uint) {
|
|
|
|
return notes.length - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getNote(uint64 idNote) constant returns(
|
|
|
|
uint amount,
|
|
|
|
uint64 owner,
|
|
|
|
uint64 nDelegates,
|
|
|
|
uint64 proposedProject,
|
2017-06-27 11:08:23 +00:00
|
|
|
uint64 commitTime,
|
2017-06-06 17:40:14 +00:00
|
|
|
uint64 oldNote,
|
|
|
|
PaymentState paymentState
|
|
|
|
) {
|
2017-07-13 17:12:45 +00:00
|
|
|
Note storage n = findNote(idNote);
|
2017-06-06 17:40:14 +00:00
|
|
|
amount = n.amount;
|
|
|
|
owner = n.owner;
|
|
|
|
nDelegates = uint64(n.delegationChain.length);
|
|
|
|
proposedProject = n.proposedProject;
|
2017-06-27 11:08:23 +00:00
|
|
|
commitTime = n.commitTime;
|
2017-06-06 17:40:14 +00:00
|
|
|
oldNote = n.oldNote;
|
|
|
|
paymentState = n.paymentState;
|
|
|
|
}
|
2017-07-09 17:04:02 +00:00
|
|
|
// This is to return the delegates one by one, because you can not return an array
|
2017-06-06 17:40:14 +00:00
|
|
|
function getNoteDelegate(uint64 idNote, uint idxDelegate) constant returns(
|
|
|
|
uint64 idDelegate,
|
|
|
|
address addr,
|
|
|
|
string name
|
|
|
|
) {
|
2017-07-13 17:12:45 +00:00
|
|
|
Note storage n = findNote(idNote);
|
2017-06-26 17:54:28 +00:00
|
|
|
idDelegate = n.delegationChain[idxDelegate - 1];
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage delegate = findManager(idDelegate);
|
2017-06-06 17:40:14 +00:00
|
|
|
addr = delegate.addr;
|
|
|
|
name = delegate.name;
|
|
|
|
}
|
|
|
|
|
2017-06-26 17:54:28 +00:00
|
|
|
function numberOfNoteManagers() constant returns(uint) {
|
2017-06-06 17:40:14 +00:00
|
|
|
return managers.length - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getNoteManager(uint64 idManager) constant returns (
|
|
|
|
NoteManagerType managerType,
|
|
|
|
address addr,
|
|
|
|
string name,
|
|
|
|
uint64 commitTime,
|
|
|
|
address reviewer,
|
|
|
|
bool canceled)
|
|
|
|
{
|
2017-07-13 17:12:45 +00:00
|
|
|
NoteManager storage m = findManager(idManager);
|
2017-06-06 17:40:14 +00:00
|
|
|
managerType = m.managerType;
|
|
|
|
addr = m.addr;
|
|
|
|
name = m.name;
|
|
|
|
commitTime = m.commitTime;
|
|
|
|
reviewer = m.reviewer;
|
|
|
|
canceled = m.canceled;
|
|
|
|
}
|
|
|
|
|
|
|
|
////////
|
|
|
|
// Private methods
|
|
|
|
///////
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
// All notes exist... but if the note hasn't been created in this system yet then it wouldn't
|
|
|
|
// be in the hash array hNoteddx[]
|
2017-07-13 17:21:53 +00:00
|
|
|
// this function creates a balloon if one is not created already... this ballon has 0 for the amount
|
2017-06-06 17:40:14 +00:00
|
|
|
function findNote(
|
|
|
|
uint64 owner,
|
|
|
|
uint64[] delegationChain,
|
|
|
|
uint64 proposedProject,
|
2017-06-27 11:08:23 +00:00
|
|
|
uint64 commitTime,
|
2017-06-06 17:40:14 +00:00
|
|
|
uint64 oldNote,
|
|
|
|
PaymentState paid
|
|
|
|
) internal returns (uint64)
|
|
|
|
{
|
2017-06-27 11:08:23 +00:00
|
|
|
bytes32 hNote = sha3(owner, delegationChain, proposedProject, commitTime, oldNote, paid);
|
2017-06-06 17:40:14 +00:00
|
|
|
uint64 idx = hNote2ddx[hNote];
|
|
|
|
if (idx > 0) return idx;
|
|
|
|
idx = uint64(notes.length);
|
2017-06-26 17:54:28 +00:00
|
|
|
hNote2ddx[hNote] = idx;
|
2017-06-27 11:08:23 +00:00
|
|
|
notes.push(Note(0, owner, delegationChain, proposedProject, commitTime, oldNote, paid));
|
2017-06-06 17:40:14 +00:00
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
function findManager(uint64 idManager) internal returns (NoteManager storage) {
|
2017-07-13 17:12:45 +00:00
|
|
|
require(idManager < managers.length);
|
2017-06-06 17:40:14 +00:00
|
|
|
return managers[idManager];
|
|
|
|
}
|
|
|
|
|
|
|
|
function findNote(uint64 idNote) internal returns (Note storage) {
|
2017-07-13 17:12:45 +00:00
|
|
|
require(idNote < notes.length);
|
2017-06-06 17:40:14 +00:00
|
|
|
return notes[idNote];
|
|
|
|
}
|
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
// a constant for the case that a delegate is requested that is not a delegate in the system
|
|
|
|
uint64 constant NOTFOUND = 0xFFFFFFFFFFFFFFFF;
|
2017-07-13 17:21:53 +00:00
|
|
|
|
2017-07-09 17:04:02 +00:00
|
|
|
// helper function that searches the delegationChain fro a specific delegate and
|
|
|
|
// level of delegation returns their idx in the delegation cahin which reflect their level of authority
|
|
|
|
function getDelegateIdx(Note n, uint64 idDelegate) internal returns(uint64) {
|
|
|
|
for (uint i=0; i<n.delegationChain.length; i++) {
|
|
|
|
if (n.delegationChain[i] == idDelegate) return uint64(i);
|
|
|
|
}
|
|
|
|
return NOTFOUND;
|
|
|
|
}
|
|
|
|
|
|
|
|
// helper function that returns the project level solely to check that there
|
2017-07-13 17:21:53 +00:00
|
|
|
// are not too many Projects that violate MAX_SUBPROJECT_LEVEL
|
2017-07-09 17:04:02 +00:00
|
|
|
function getProjectLevel(Note n) internal returns(uint) {
|
|
|
|
if (n.oldNote == 0) return 0;//changed
|
|
|
|
Note oldN = findNote(n.oldNote);
|
|
|
|
return getProjectLevel(oldN) + 1;
|
|
|
|
}
|
|
|
|
// this makes it easy to cancel projects
|
2017-07-13 17:21:53 +00:00
|
|
|
// @param idNote the note that may or may not be cancelled
|
2017-07-09 17:04:02 +00:00
|
|
|
function getOldestNoteNotCanceled(uint64 idNote) internal constant returns(uint64) { //todo rename
|
2017-06-27 11:08:23 +00:00
|
|
|
if (idNote == 0) return 0;
|
2017-07-13 17:12:45 +00:00
|
|
|
Note storage n = findNote(idNote);
|
|
|
|
NoteManager storage owner = findManager(n.owner);
|
2017-06-27 11:08:23 +00:00
|
|
|
if (owner.managerType == NoteManagerType.Donor) return idNote;
|
2017-06-06 17:40:14 +00:00
|
|
|
|
2017-07-13 17:21:53 +00:00
|
|
|
// This function calls itself to iterate up the chain to check which
|
|
|
|
// projects are cancelled, confirming that it is returning the Oldest valid Note
|
2017-06-06 17:40:14 +00:00
|
|
|
uint64 parentProject = getOldestNoteNotCanceled(n.oldNote);
|
2017-06-27 11:08:23 +00:00
|
|
|
|
|
|
|
if (owner.canceled) { // Current project is canceled.
|
|
|
|
return parentProject;
|
|
|
|
} else if (parentProject == n.oldNote) { // None of the top projects is canceled
|
|
|
|
return idNote;
|
|
|
|
} else { // Current is not canceled but some ont the top yes
|
2017-06-06 17:40:14 +00:00
|
|
|
return parentProject;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|