2017-07-13 17:12:45 +00:00
|
|
|
const ethConnector = require('ethconnector');
|
|
|
|
const chai = require('chai');
|
|
|
|
const assert = chai.assert;
|
|
|
|
const LiquidPledging = require('../js/liquidPledging.js')(true);
|
|
|
|
const Vault = require('../js/vault.js');
|
2017-06-27 11:08:23 +00:00
|
|
|
const assertFail = require("./helpers/assertFail");
|
2017-07-13 17:12:45 +00:00
|
|
|
const getBalance = require("runethtx").getBalance;
|
2017-06-27 11:08:23 +00:00
|
|
|
|
|
|
|
const getNote = async (liquidPledging, idNote) => {
|
|
|
|
const note = {
|
|
|
|
delegates: [],
|
|
|
|
};
|
|
|
|
const res = await liquidPledging.getNote(idNote);
|
|
|
|
note.amount = res[0];
|
|
|
|
note.owner = res[1];
|
|
|
|
for (let i=1; i <= res[2].toNumber(); i += 1) {
|
|
|
|
const delegate = {};
|
|
|
|
const resd = await liquidPledging.getNoteDelegate(idNote, i);
|
|
|
|
delegate.id = resd[0].toNumber();
|
|
|
|
delegate.addr = resd[1];
|
|
|
|
delegate.name = resd[2];
|
|
|
|
note.delegates.push(delegate);
|
|
|
|
}
|
|
|
|
if (res[3].toNumber()) {
|
|
|
|
note.proposedProject = res[3].toNumber();
|
|
|
|
note.commmitTime = res[4].toNumber();
|
|
|
|
}
|
|
|
|
if (res[5].toNumber()) {
|
|
|
|
note.oldProject = res[5].toNumber();
|
|
|
|
}
|
|
|
|
if (res[6].toNumber() == 0) {
|
|
|
|
note.paymentState = "NotPaid";
|
|
|
|
} else if (res[6].toNumber() == 1) {
|
|
|
|
note.paymentState = "Paying";
|
|
|
|
} else if (res[6].toNumber() == 2) {
|
|
|
|
note.paymentState = "Paid";
|
|
|
|
} else {
|
|
|
|
note.paymentState = "Unknown";
|
|
|
|
}
|
|
|
|
return note;
|
|
|
|
};
|
|
|
|
|
|
|
|
const getManager = async (liquidPledging, idManager) => {
|
|
|
|
const manager = {};
|
|
|
|
const res = await liquidPledging.getNoteManager(idManager);
|
|
|
|
if (res[0].toNumber() == 0) {
|
|
|
|
manager.paymentState = "Donor";
|
|
|
|
} else if (res[0].toNumber() === 1) {
|
|
|
|
manager.paymentState = "Delegate";
|
|
|
|
} else if (res[0].toNumber() === 2) {
|
|
|
|
manager.paymentState = "Project";
|
|
|
|
} else {
|
|
|
|
manager.paymentState = "Unknown";
|
|
|
|
}
|
|
|
|
manager.addr = res[1];
|
|
|
|
manager.name = res[2];
|
|
|
|
manager.commitTime = res[3].toNumber();
|
|
|
|
if (manager.paymentState == "Project") {
|
|
|
|
manager.reviewer = res[4];
|
|
|
|
manager.canceled = res[5];
|
|
|
|
}
|
|
|
|
return manager;
|
|
|
|
};
|
|
|
|
|
|
|
|
const getState = async (liquidPledging) => {
|
|
|
|
const st = {
|
|
|
|
notes: [null],
|
|
|
|
managers: [null],
|
|
|
|
};
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
for (let i=1; i <= nNotes; i += 1) {
|
|
|
|
const note = await getNote(liquidPledging, i);
|
|
|
|
st.notes.push(note);
|
|
|
|
}
|
|
|
|
|
|
|
|
const nManagers = await liquidPledging.numberOfNoteManagers();
|
|
|
|
for (let i=1; i <= nManagers; i += 1) {
|
|
|
|
const manager = await getManager(liquidPledging, i);
|
|
|
|
st.managers.push(manager);
|
|
|
|
}
|
|
|
|
return st;
|
|
|
|
};
|
|
|
|
|
|
|
|
const printState = async(liquidPledging) => {
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
console.log(JSON.stringify(st, null, 2));
|
|
|
|
};
|
|
|
|
|
|
|
|
const printBalances = async(liquidPledging) => {
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 13);
|
|
|
|
for (let i=1; i<=12; i++) {
|
|
|
|
console.log(i, web3.fromWei(st.notes[ i ].amount).toNumber() )
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-07-13 17:12:45 +00:00
|
|
|
describe("LiquidPledging test", () => {
|
|
|
|
let web3;
|
|
|
|
let accounts;
|
2017-06-26 17:54:28 +00:00
|
|
|
let liquidPledging;
|
|
|
|
let vault;
|
2017-07-13 17:12:45 +00:00
|
|
|
let donor1;
|
|
|
|
let delegate1;
|
|
|
|
let adminProject1;
|
|
|
|
let adminProject2;
|
|
|
|
let adminProject2a;
|
|
|
|
let delegate2;
|
|
|
|
let reviewer;
|
|
|
|
before((done) => {
|
|
|
|
ethConnector.init("testrpc", { gasLimit: 4000000 }, () => {
|
|
|
|
web3 = ethConnector.web3;
|
|
|
|
accounts = ethConnector.accounts;
|
|
|
|
donor1 = accounts[1];
|
|
|
|
delegate1 = accounts[2];
|
|
|
|
adminProject1 = accounts[3];
|
|
|
|
adminProject2 = accounts[4];
|
|
|
|
adminProject2a = accounts[5];
|
|
|
|
delegate2 = accounts[6];
|
|
|
|
reviewer = accounts[7];
|
|
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
2017-06-26 17:54:28 +00:00
|
|
|
it("Should deploy LiquidPledgin contract", async () => {
|
2017-07-13 17:12:45 +00:00
|
|
|
vault = await Vault.new(web3);
|
|
|
|
liquidPledging = await LiquidPledging.new(web3, vault.$address);
|
|
|
|
await vault.setLiquidPledging(liquidPledging.$address);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("Should create a donor", async () => {
|
|
|
|
await liquidPledging.addDonor("Donor1", 86400, {from: donor1});
|
|
|
|
const nManagers = await liquidPledging.numberOfNoteManagers();
|
|
|
|
assert.equal(nManagers, 1);
|
|
|
|
const res = await liquidPledging.getNoteManager(1);
|
|
|
|
assert.equal(res[0], 0); // Donor
|
|
|
|
assert.equal(res[1], donor1);
|
|
|
|
assert.equal(res[2], "Donor1");
|
|
|
|
assert.equal(res[3], 86400);
|
|
|
|
});
|
|
|
|
it("Should make a donation", async () => {
|
|
|
|
await liquidPledging.donate(1, 1, {from: donor1, value: web3.toWei(1)});
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 1);
|
|
|
|
const res = await liquidPledging.getNote(1);
|
|
|
|
});
|
|
|
|
it("Should create a delegate", async () => {
|
|
|
|
await liquidPledging.addDelegate("Delegate1", {from: delegate1});
|
|
|
|
const nManagers = await liquidPledging.numberOfNoteManagers();
|
|
|
|
assert.equal(nManagers, 2);
|
|
|
|
const res = await liquidPledging.getNoteManager(2);
|
|
|
|
assert.equal(res[0], 1); // Donor
|
|
|
|
assert.equal(res[1], delegate1);
|
|
|
|
assert.equal(res[2], "Delegate1");
|
|
|
|
});
|
|
|
|
it("Donor should delegate on the delegate ", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.transfer(1, 1, web3.toWei(0.5), 2, {from: donor1});
|
2017-06-26 17:54:28 +00:00
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 2);
|
|
|
|
const res1 = await liquidPledging.getNote(1);
|
|
|
|
assert.equal(res1[0].toNumber(), web3.toWei(0.5));
|
|
|
|
const res2 = await liquidPledging.getNote(2);
|
|
|
|
assert.equal(res2[0].toNumber(), web3.toWei(0.5));
|
|
|
|
assert.equal(res2[1].toNumber(), 1); // One delegate
|
|
|
|
|
|
|
|
const d = await liquidPledging.getNoteDelegate(2, 1);
|
|
|
|
assert.equal(d[0], 2);
|
|
|
|
assert.equal(d[1], delegate1);
|
|
|
|
assert.equal(d[2], "Delegate1");
|
|
|
|
});
|
|
|
|
it("Should create a 2 projects", async () => {
|
|
|
|
await liquidPledging.addProject("Project1", reviewer, 86400, {from: adminProject1});
|
|
|
|
|
|
|
|
const nManagers = await liquidPledging.numberOfNoteManagers();
|
|
|
|
assert.equal(nManagers, 3);
|
|
|
|
const res = await liquidPledging.getNoteManager(3);
|
|
|
|
assert.equal(res[0], 2); // Project type
|
|
|
|
assert.equal(res[1], adminProject1);
|
|
|
|
assert.equal(res[2], "Project1");
|
|
|
|
assert.equal(res[3], 86400);
|
|
|
|
assert.equal(res[4], reviewer);
|
|
|
|
assert.equal(res[5], false);
|
|
|
|
|
|
|
|
await liquidPledging.addProject("Project2", reviewer, 86400, {from: adminProject2});
|
|
|
|
|
|
|
|
const nManagers2 = await liquidPledging.numberOfNoteManagers();
|
|
|
|
assert.equal(nManagers2, 4);
|
|
|
|
const res4 = await liquidPledging.getNoteManager(4);
|
|
|
|
assert.equal(res4[0], 2); // Project type
|
|
|
|
assert.equal(res4[1], adminProject2);
|
|
|
|
assert.equal(res4[2], "Project2");
|
|
|
|
assert.equal(res4[3], 86400);
|
|
|
|
assert.equal(res4[4], reviewer);
|
|
|
|
assert.equal(res4[5], false);
|
|
|
|
});
|
|
|
|
it("Delegate should assign to project1", async () => {
|
|
|
|
const n = Math.floor(new Date().getTime() / 1000);
|
|
|
|
await liquidPledging.transfer(2, 2, web3.toWei(0.2), 3, {from: delegate1});
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 3);
|
|
|
|
const res3 = await liquidPledging.getNote(3);
|
|
|
|
assert.equal(res3[0].toNumber(), web3.toWei(0.2));
|
|
|
|
assert.equal(res3[1].toNumber(), 1); // Owner
|
|
|
|
assert.equal(res3[2].toNumber(), 1); // Delegates
|
|
|
|
assert.equal(res3[3].toNumber(), 3); // Proposed Project
|
2017-07-13 17:12:45 +00:00
|
|
|
assert.isAbove(res3[4].toNumber(), n + 86000);
|
2017-06-26 17:54:28 +00:00
|
|
|
assert.equal(res3[5].toNumber(), 0); // Old Node
|
|
|
|
assert.equal(res3[6].toNumber(), 0); // Not Paid
|
|
|
|
});
|
|
|
|
it("Donor should change his mind and assign half of it to project2", async () => {
|
|
|
|
const n = Math.floor(new Date().getTime() / 1000);
|
|
|
|
await liquidPledging.transfer(1, 3, web3.toWei(0.1), 4, {from: donor1});
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 4);
|
|
|
|
const res3 = await liquidPledging.getNote(3);
|
|
|
|
assert.equal(res3[0].toNumber(), web3.toWei(0.1));
|
|
|
|
const res4 = await liquidPledging.getNote(4);
|
|
|
|
assert.equal(res4[1].toNumber(), 4); // Owner
|
|
|
|
assert.equal(res4[2].toNumber(), 0); // Delegates
|
|
|
|
assert.equal(res4[3].toNumber(), 0); // Proposed Project
|
|
|
|
assert.equal(res4[4], 0);
|
|
|
|
assert.equal(res4[5].toNumber(), 2); // Old Node
|
|
|
|
assert.equal(res4[6].toNumber(), 0); // Not Paid
|
|
|
|
});
|
|
|
|
it("After the time, the project1 should be able to spend part of it", async () => {
|
|
|
|
const n = Math.floor(new Date().getTime() / 1000);
|
|
|
|
await liquidPledging.setMockedTime(n + 86401);
|
|
|
|
await liquidPledging.withdraw(3, web3.toWei(0.05), {from: adminProject1});
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 6);
|
|
|
|
const res5 = await liquidPledging.getNote(5);
|
|
|
|
assert.equal(res5[0].toNumber(), web3.toWei(0.05));
|
|
|
|
assert.equal(res5[1].toNumber(), 3); // Owner
|
|
|
|
assert.equal(res5[2].toNumber(), 0); // Delegates
|
|
|
|
assert.equal(res5[3].toNumber(), 0); // Proposed Project
|
|
|
|
assert.equal(res5[4], 0); // commit time
|
|
|
|
assert.equal(res5[5].toNumber(), 2); // Old Node
|
|
|
|
assert.equal(res5[6].toNumber(), 0); // Not Paid
|
|
|
|
const res6 = await liquidPledging.getNote(6);
|
|
|
|
assert.equal(res6[0].toNumber(), web3.toWei(0.05));
|
|
|
|
assert.equal(res6[1].toNumber(), 3); // Owner
|
|
|
|
assert.equal(res6[2].toNumber(), 0); // Delegates
|
|
|
|
assert.equal(res6[3].toNumber(), 0); // Proposed Project
|
|
|
|
assert.equal(res6[4], 0); // commit time
|
|
|
|
assert.equal(res6[5].toNumber(), 2); // Old Node
|
|
|
|
assert.equal(res6[6].toNumber(), 1); // Peinding paid Paid
|
|
|
|
});
|
|
|
|
it("Should collect the Ether", async () => {
|
2017-07-13 17:12:45 +00:00
|
|
|
const initialBalance = await getBalance(web3, adminProject1);
|
2017-06-26 17:54:28 +00:00
|
|
|
|
|
|
|
await vault.confirmPayment(0);
|
2017-07-13 17:12:45 +00:00
|
|
|
const finalBalance = await getBalance(web3, adminProject1);
|
2017-06-26 17:54:28 +00:00
|
|
|
|
|
|
|
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
|
|
|
|
|
|
|
|
assert.equal(collected, 0.05);
|
|
|
|
|
|
|
|
const nNotes = await liquidPledging.numberOfNotes();
|
|
|
|
assert.equal(nNotes.toNumber(), 7);
|
|
|
|
const res7 = await liquidPledging.getNote(7);
|
|
|
|
assert.equal(res7[0].toNumber(), web3.toWei(0.05));
|
|
|
|
assert.equal(res7[1].toNumber(), 3); // Owner
|
|
|
|
assert.equal(res7[2].toNumber(), 0); // Delegates
|
|
|
|
assert.equal(res7[3].toNumber(), 0); // Proposed Project
|
|
|
|
assert.equal(res7[4], 0); // commit time
|
|
|
|
assert.equal(res7[5].toNumber(), 2); // Old Node
|
|
|
|
assert.equal(res7[6].toNumber(), 2); // Peinding paid Paid
|
|
|
|
});
|
|
|
|
it("Reviewer should be able to cancel project1", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.cancelProject(3, {from: reviewer});
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.managers[3].canceled , true);
|
|
|
|
});
|
|
|
|
it("Should not allow to withdraw from a canceled project", async () => {
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(web3.fromWei(st.notes[5].amount).toNumber(), 0.05);
|
|
|
|
await assertFail(async function() {
|
|
|
|
await liquidPledging.withdraw(5, web3.toWei(0.01), {from: adminProject1});
|
|
|
|
});
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("Delegate should send part of this ETH to project2", async () => {
|
2017-07-13 17:12:45 +00:00
|
|
|
await liquidPledging.transfer(2, 5, web3.toWei(0.03), 4,{$extraGas: 100000}, {from: delegate1});
|
2017-06-27 11:08:23 +00:00
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 9);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 8 ].amount).toNumber(), 0.03);
|
|
|
|
assert.equal(st.notes[8].owner, 1);
|
|
|
|
assert.equal(st.notes[8].delegates.length, 1);
|
|
|
|
assert.equal(st.notes[8].delegates[0].id, 2);
|
|
|
|
assert.equal(st.notes[8].proposedProject, 4);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
2017-06-27 11:08:23 +00:00
|
|
|
it("Donor should be able to send the remaining to project2", async () => {
|
|
|
|
await liquidPledging.transfer(1, 5, web3.toWei(0.02), 4, {from: donor1});
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 9);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 5 ].amount).toNumber(), 0);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 4 ].amount).toNumber(), 0.12);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("A subproject 2a and a delegate2 is created", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.addProject("Project2a", reviewer, 86400, {from: adminProject2a});
|
|
|
|
await liquidPledging.addDelegate("Delegate2", {from: delegate2});
|
|
|
|
const nManagers = await liquidPledging.numberOfNoteManagers();
|
|
|
|
assert.equal(nManagers, 6);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("Project 2 delegate in delegate2", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.transfer(4, 4, web3.toWei(0.02), 6, {from: adminProject2});
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 10);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 9 ].amount).toNumber(), 0.02);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 4 ].amount).toNumber(), 0.1);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("delegate2 assigns to projec2a", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.transfer(6, 9, web3.toWei(0.01), 5, {from: delegate2});
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 11);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 9 ].amount).toNumber(), 0.01);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 10 ].amount).toNumber(), 0.01);
|
2017-07-13 17:12:45 +00:00
|
|
|
}).timeout(4000);
|
2017-06-27 11:08:23 +00:00
|
|
|
it("project2a authorize to spend a little", async () => {
|
|
|
|
const n = Math.floor(new Date().getTime() / 1000);
|
|
|
|
await liquidPledging.setMockedTime(n + 86401*3);
|
|
|
|
await liquidPledging.withdraw(10, web3.toWei(0.005), {from: adminProject2a});
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 13);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 10 ].amount).toNumber(), 0);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 11 ].amount).toNumber(), 0.005);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 12 ].amount).toNumber(), 0.005);
|
2017-07-13 17:12:45 +00:00
|
|
|
}).timeout(4000);
|
2017-06-26 17:54:28 +00:00
|
|
|
it("project2 is canceled", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.cancelProject(4, {from: reviewer});
|
|
|
|
});
|
|
|
|
it("project2 should not be able to confirm payment", async () => {
|
|
|
|
await assertFail(async function() {
|
|
|
|
await vault.confirmPayment(1);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
it("Should not be able to withdraw it", async() => {
|
|
|
|
await assertFail(async function() {
|
|
|
|
await liquidPledging.withdraw(12, web3.toWei(0.005), {from: donor1});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
it("Should not be able to cancel payment", async() => {
|
|
|
|
await vault.cancelPayment(1);
|
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
assert.equal(st.notes.length, 13);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 2 ].amount).toNumber(), 0.31);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 11 ].amount).toNumber(), 0);
|
|
|
|
assert.equal(web3.fromWei(st.notes[ 12 ].amount).toNumber(), 0);
|
2017-06-26 17:54:28 +00:00
|
|
|
});
|
|
|
|
it("original owner should recover the remaining funds", async () => {
|
2017-06-27 11:08:23 +00:00
|
|
|
const st = await getState(liquidPledging);
|
|
|
|
await liquidPledging.withdraw(1, web3.toWei(0.5), {from: donor1});
|
|
|
|
await liquidPledging.withdraw(2, web3.toWei(0.31), {from: donor1});
|
|
|
|
await liquidPledging.withdraw(4, web3.toWei(0.1), {from: donor1});
|
|
|
|
|
2017-07-13 17:12:45 +00:00
|
|
|
await liquidPledging.withdraw(8, web3.toWei(0.03), {$extraGas: 100000}, {from: donor1});
|
2017-06-27 11:08:23 +00:00
|
|
|
await liquidPledging.withdraw(9, web3.toWei(0.01), {from: donor1});
|
|
|
|
|
2017-07-13 17:12:45 +00:00
|
|
|
const initialBalance = await getBalance(web3, donor1);
|
2017-06-27 11:08:23 +00:00
|
|
|
await vault.multiConfirm([2,3,4,5,6]);
|
|
|
|
|
2017-07-13 17:12:45 +00:00
|
|
|
const finalBalance = await getBalance(web3, donor1);
|
2017-06-27 11:08:23 +00:00
|
|
|
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
|
2017-06-26 17:54:28 +00:00
|
|
|
|
2017-06-27 11:08:23 +00:00
|
|
|
assert.equal(collected, 0.95);
|
2017-07-13 17:12:45 +00:00
|
|
|
}).timeout(8000);
|
2017-06-26 17:54:28 +00:00
|
|
|
|
|
|
|
});
|