status-im
/
liquid-funding
mirror of https://github.com/status-im/liquid-funding.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #2 from perissology/master 

update to use web3 1.0
This commit is contained in:
Jordi Baylina 2017-10-04 10:01:36 +02:00 committed by GitHub
parent 28ecaff0ce 5f3a73b5c1
commit 0de789ef30
4 changed files with 313 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

361
js/liquidPledging.js
View File

@ -1,198 +1,215 @@
/* eslint-disable no-await-in-loop */
const LiquidPledgingAbi = require('../build/LiquidPledging.sol').LiquidPledgingAbi;
const LiquidPledgingCode = require('../build/LiquidPledging.sol').LiquidPledgingByteCode;
const LiquidPledgingMockAbi = require('../build/LiquidPledgingMock.sol').LiquidPledgingMockAbi;
const LiquidPledgingMockCode = require('../build/LiquidPledgingMock.sol').LiquidPledgingMockByteCode;
const runethtx = require('runethtx');
const generateClass = require('eth-contract-class').default;
module.exports = (test) => {
const LiquidPledgingContract = test ?
runethtx.generateClass(LiquidPledgingMockAbi, LiquidPledgingMockCode) :
runethtx.generateClass(LiquidPledgingAbi, LiquidPledgingCode);
const $abi = (test) ? LiquidPledgingMockAbi : LiquidPledgingAbi;
const $byteCode = (test) ? LiquidPledgingMockCode : LiquidPledgingCode;
return class LiquidPledging extends LiquidPledgingContract {
constructor(web3, address) {
super(web3, address);
this.pledges = [];
this.managers = [];
this.b = 'xxxxxxx b xxxxxxxx';
}
const LiquidPledging = generateClass($abi, $byteCode);
async $getPledge(idPledge) {
const pledge = {
delegates: [],
};
const res = await this.getPledge(idPledge);
pledge.amount = res[0];
pledge.owner = res[1];
for (let i = 1; i <= res[2].toNumber(); i += 1) {
const delegate = {};
const resd = await this.getPledgeDelegate(idPledge, i);
delegate.id = resd[0].toNumber();
delegate.addr = resd[1];
delegate.name = resd[2];
pledge.delegates.push(delegate);
}
if (res[3].toNumber()) {
pledge.proposedCampaign = res[3].toNumber();
pledge.commmitTime = res[4].toNumber();
}
if (res[5].toNumber()) {
pledge.oldCampaign = res[5].toNumber();
}
if (res[6].toNumber() === 0) {
pledge.paymentState = 'NotPaid';
} else if (res[6].toNumber() === 1) {
pledge.paymentState = 'Paying';
} else if (res[6].toNumber() === 2) {
pledge.paymentState = 'Paid';
} else {
pledge.paymentState = 'Unknown';
}
return pledge;
}
LiquidPledging.prototype.$getPledge = function (idPledge) {
const pledge = {
delegates: [],
};
async $getManager(idManager) {
const manager = {};
const res = await this.getPledgeManager(idManager);
if (res[0].toNumber() === 0) {
manager.paymentState = 'Giver';
} else if (res[0].toNumber() === 1) {
manager.paymentState = 'Delegate';
} else if (res[0].toNumber() === 2) {
manager.paymentState = 'Campaign';
} else {
manager.paymentState = 'Unknown';
}
manager.addr = res[1];
manager.name = res[2];
manager.commitTime = res[3].toNumber();
if (manager.paymentState === 'Campaign') {
manager.parentCampaign = res[4];
manager.canceled = res[5];
}
return manager;
}
return this.getPledge(idPledge)
.then((res) => {
pledge.amount = res.amount;
pledge.owner = res.owner;
async getState() {
const st = {
pledges: [null],
managers: [null],
};
const nPledges = await this.numberOfPledges();
for (let i = 1; i <= nPledges; i += 1) {
const pledge = await this.$getPledge(i);
st.pledges.push(pledge);
}
if (res.proposedCampaign) {
pledge.proposedCampaign = res.proposedCampaign;
pledge.commmitTime = res.commitTime;
}
if (res.oldPledge) {
pledge.oldPledge = res.oldPledge;
}
if (res.paymentState === '0') {
pledge.paymentState = 'NotPaid';
} else if (res.paymentState === '1') {
pledge.paymentState = 'Paying';
} else if (res.paymentState === '2') {
pledge.paymentState = 'Paid';
} else {
pledge.paymentState = 'Unknown';
}
const nManagers = await this.numberOfPledgeManagers();
for (let i = 1; i <= nManagers; i += 1) {
const manager = await this.$getManager(i);
st.managers.push(manager);
}
return st;
}
const promises = [];
for (let i = 1; i <= res.nDelegates; i += 1) {
promises.push(
this.getPledgeDelegate(idPledge, i)
.then(r => ({
id: r.idDelegate,
addr: r.addr,
name: r.name,
})),
);
}
generateGiversState() {
const giversState = [];
return Promise.all(promises);
})
.then((delegates) => {
pledge.delegates = delegates;
return pledge;
});
};
const getGiver = (idPledge) => {
let pledge = this.pledges[idPledge];
while (pledge.oldNode) pledge = this.pledges[idPledge];
return pledge.owner;
};
LiquidPledging.prototype.$getManager = function (idManager) {
const manager = {};
return this.getPledgeManager(idManager)
.then((res) => {
if (res.managerType === '0') {
manager.type = 'Giver';
} else if (res.managerType === '1') {
manager.type = 'Delegate';
} else if (res.managerType === '2') {
manager.type = 'Campaign';
} else {
manager.type = 'Unknown';
}
manager.addr = res.addr;
manager.name = res.name;
manager.commitTime = res.commitTime;
if (manager.paymentState === 'Campaign') {
manager.parentCampaign = res.parentCampaign;
manager.canceled = res.canceled;
}
manager.plugin = res.plugin;
manager.canceled = res.canceled;
return manager;
});
};
LiquidPledging.prototype.getState = function () {
const getPledges = () => this.numberOfPledges()
.then((nPledges) => {
const promises = [];
for (let i = 1; i <= nPledges; i += 1) {
promises.push(this.$getPledge(i));
}
return Promise.all(promises);
});
const getManagers = () => this.numberOfPledgeManagers()
.then((nManagers) => {
const promises = [];
for (let i = 1; i <= nManagers; i += 1) {
promises.push(this.$getManager(i));
}
return Promise.all(promises);
});
return Promise.all([getPledges(), getManagers()])
.then(([pledges, managers]) => ({
pledges: [null, ...pledges],
managers: [null, ...managers],
}));
};
LiquidPledging.prototype.generateGiversState = function () {
const giversState = [];
const getGiver = (idPledge) => {
let pledge = this.pledges[idPledge];
while (pledge.oldNode) pledge = this.pledges[idPledge];
return pledge.owner;
};
// Add a giver structure to the list
const addGiver = (_list, idGiver) => {
const list = _list;
if (!list[idGiver]) {
list[idGiver] = {
idGiver,
notAssigned: {
pledges: [],
delegates: [],
},
precommitedCampaigns: [],
commitedCampaigns: [],
};
}
};
const addGiver = (_list, idGiver) => {
const list = _list;
if (!list[idGiver]) {
list[idGiver] = {
idGiver,
notAssigned: {
pledges: [],
delegates: [],
},
precommitedCampaigns: [],
commitedCampaigns: [],
};
}
};
// Add a delegate structure to the list
const addDelegate = (_list, idDelegate) => {
const list = _list;
if (!list[idDelegate]) {
list[idDelegate] = {
idDelegate,
name: this.managers[idDelegate].name,
pledges: [],
delegtes: [],
};
}
};
const addDelegate = (_list, idDelegate) => {
const list = _list;
if (!list[idDelegate]) {
list[idDelegate] = {
idDelegate,
name: this.managers[idDelegate].name,
pledges: [],
delegtes: [],
};
}
};
const addCampaign = (_list, idCampaign) => {
const list = _list;
if (!list[idCampaign]) {
list[idCampaign] = {
idCampaign,
pledges: [],
commitedCampaigns: [],
name: this.managers[idCampaign].name,
commitTime: this.managers[idCampaign].commitTime,
owner: this.managers[idCampaign].owner,
parentCampaign: this.managers[idCampaign].parentCampaign,
};
}
};
const addCampaign = (_list, idCampaign) => {
const list = _list;
if (!list[idCampaign]) {
list[idCampaign] = {
idCampaign,
pledges: [],
commitedCampaigns: [],
name: this.managers[idCampaign].name,
commitTime: this.managers[idCampaign].commitTime,
owner: this.managers[idCampaign].owner,
parentCampaign: this.managers[idCampaign].parentCampaign,
};
}
};
const addDelegatePledge = (stGiver, idPledge) => {
const pledge = this.pledges[idPledge];
stGiver.notAssigned.pledges.push(idPledge);
let list = stGiver.notAssigned.delegates;
for (let i = 0; i < pledge.delegationChain.length; i += 1) {
const idDelegate = pledge.delegationChain[i];
addDelegate(list, idDelegate);
list = list[idDelegate].delegates;
}
};
const addDelegatePledge = (stGiver, idPledge) => {
const pledge = this.pledges[idPledge];
stGiver.notAssigned.pledges.push(idPledge);
let list = stGiver.notAssigned.delegates;
for (let i = 0; i < pledge.delegationChain.length; i += 1) {
const idDelegate = pledge.delegationChain[i];
addDelegate(list, idDelegate);
list = list[idDelegate].delegates;
}
};
const addCampaignPledge = (stGiver, idPledge) => {
const pledge = this.pledges[idPledge];
const addCampaignPledge = (stGiver, idPledge) => {
const pledge = this.pledges[idPledge];
const campaignList = [];
let n = pledge;
while (n.oldNode) {
campaignList.unshift(n.owner);
n = this.pledges[n.oldNode];
}
let list = stGiver.commitedCampaigns;
for (let j = 0; j < campaignList.length; j += 1) {
addCampaign(list, campaignList[j]);
list[campaignList[j]].pledges.push(idPledge);
list = list[campaignList[j]].commitedCampaigns;
}
};
for (let i = 0; i < this.pledges; i += 1) {
const idPledge = this.pledges[i];
const idGiver = getGiver(idPledge);
addGiver(giversState, idGiver);
const stGiver = giversState[idGiver];
const pledge = this.pledges[idPledge];
if ((pledge.owner === idGiver) && (pledge.precommitedCampaign === 0)) {
addDelegatePledge(stGiver, idPledge);
} else if ((pledge.owner === idGiver) && (pledge.precommitedCampaign !== 0)) {
addCampaign(stGiver.precommitedCampaigns, pledge.precommitedCampaign);
stGiver.precommitedCampaigns[pledge.precommitedCampaign].pledges.push(idPledge);
} else {
addCampaignPledge(stGiver, idPledge);
}
const campaignList = [];
let n = pledge;
while (n.oldNode) {
campaignList.unshift(n.owner);
n = this.pledges[n.oldNode];
}
this.giverssState = giversState;
let list = stGiver.commitedCampaigns;
for (let j = 0; j < campaignList.length; j += 1) {
addCampaign(list, campaignList[j]);
list[campaignList[j]].pledges.push(idPledge);
list = list[campaignList[j]].commitedCampaigns;
}
};
for (let i = 0; i < this.pledges; i += 1) {
const idPledge = this.pledges[i];
const idGiver = getGiver(idPledge);
addGiver(giversState, idGiver);
const stGiver = giversState[idGiver];
const pledge = this.pledges[idPledge];
if ((pledge.owner === idGiver) && (pledge.precommitedCampaign === 0)) {
addDelegatePledge(stGiver, idPledge);
} else if ((pledge.owner === idGiver) && (pledge.precommitedCampaign !== 0)) {
addCampaign(stGiver.precommitedCampaigns, pledge.precommitedCampaign);
stGiver.precommitedCampaigns[pledge.precommitedCampaign].pledges.push(idPledge);
} else {
addCampaignPledge(stGiver, idPledge);
}
}
this.giversState = giversState;
};
return LiquidPledging;
};

8
js/vault.js
View File

@ -1,5 +1,5 @@
const VaultAbi = require("../build/Vault.sol").VaultAbi;
const VaultByteCode = require("../build/Vault.sol").VaultByteCode;
const runethtx = require("runethtx");
const VaultAbi = require('../build/Vault.sol').VaultAbi;
const VaultByteCode = require('../build/Vault.sol').VaultByteCode;
const generateClass = require('eth-contract-class').default;
module.exports = runethtx.generateClass(VaultAbi, VaultByteCode);
module.exports = generateClass(VaultAbi, VaultByteCode);

11
package.json
View File

@ -34,16 +34,17 @@
"eslint-plugin-import": "^2.6.0",
"eslint-plugin-jsx-a11y": "^6.0.2",
"eslint-plugin-react": "^7.1.0",
"ethereumjs-testrpc": "^3.0.5",
"ethereumjs-testrpc": "git://github.com/perissology/testrpc.git#81216dbc",
"lerna": "^2.2.0",
"random-bytes": "^1.0.0",
"mocha": "^3.5.0",
"solcpiler": "0.0.4"
"solcpiler": "0.0.4",
"web3": "git://github.com/perissology/web3.js.git#all_fixes"
},
"homepage": "https://github.com/Giveth/liquidpledging#readme",
"dependencies": {
"async": "^2.4.0",
"ethconnector": "0.0.25",
"runethtx": "0.1.1",
"chai": "^4.1.0"
"chai": "^4.1.0",
"eth-contract-class": "0.0.4"
}
}

219
test/NormalOperation.js
View File

@ -1,31 +1,33 @@
/* eslint-env mocha */
/* eslint-disable no-await-in-loop */
const ethConnector = require('ethconnector');
const TestRPC = require('ethereumjs-testrpc');
const Web3 = require('web3');
const chai = require('chai');
const getBalance = require('runethtx').getBalance;
const liquidpledging = require('../index.js');
const assertFail = require('./helpers/assertFail');
const { utils } = Web3;
const LiquidPledging = liquidpledging.LiquidPledging(true);
const Vault = liquidpledging.Vault;
const assert = chai.assert;
const printState = async(liquidPledging) => {
const printState = async (liquidPledging) => {
console.log(liquidPledging.b);
const st = await liquidPledging.getState();
console.log(JSON.stringify(st, null, 2));
};
const printBalances = async(liquidPledging) => {
const printBalances = async (liquidPledging) => {
const st = await liquidPledging.getState();
assert.equal(st.pledges.length, 13);
for (let i = 1; i <= 12; i += 1) {
console.log(i, ethConnector.web3.fromWei(st.pledges[i].amount).toNumber());
console.log(i, Web3.utils.fromWei(st.pledges[i].amount));
}
};
const readTest = async(liquidPledging) => {
const readTest = async (liquidPledging) => {
const t1 = await liquidPledging.test1();
const t2 = await liquidPledging.test2();
const t3 = await liquidPledging.test3();
@ -48,19 +50,24 @@ describe('LiquidPledging test', () => {
let adminCampaign2;
let adminCampaign2a;
let delegate2;
before((done) => {
ethConnector.init('testrpc', { gasLimit: 5200000 }, () => {
web3 = ethConnector.web3;
accounts = ethConnector.accounts;
giver1 = accounts[1];
delegate1 = accounts[2];
adminCampaign1 = accounts[3];
adminCampaign2 = accounts[4];
adminCampaign2a = accounts[5];
delegate2 = accounts[6];
giver2 = accounts[7];
done();
before(async () => {
const testrpc = TestRPC.server({
ws: true,
gasLimit: 5200000,
total_accounts: 10,
});
testrpc.listen(8546, '127.0.0.1');
web3 = new Web3('ws://localhost:8546');
accounts = await web3.eth.getAccounts();
giver1 = accounts[1];
delegate1 = accounts[2];
adminCampaign1 = accounts[3];
adminCampaign2 = accounts[4];
adminCampaign2a = accounts[5];
delegate2 = accounts[6];
giver2 = accounts[7];
});
it('Should deploy LiquidPledging contract', async () => {
vault = await Vault.new(web3);
@ -78,9 +85,9 @@ describe('LiquidPledging test', () => {
assert.equal(res[3], 86400);
}).timeout(6000);
it('Should make a donation', async () => {
await liquidPledging.donate(1, 1, { from: giver1, value: web3.toWei(1) });
await liquidPledging.donate(1, 1, { from: giver1, value: utils.toWei(1) });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 1);
assert.equal(nPledges, 1);
await liquidPledging.getPledge(1);
}).timeout(6000);
it('Should create a delegate', async () => {
@ -93,14 +100,14 @@ describe('LiquidPledging test', () => {
assert.equal(res[2], 'Delegate1');
}).timeout(6000);
it('Giver should delegate on the delegate', async () => {
await liquidPledging.transfer(1, 1, web3.toWei(0.5), 2, { from: giver1 });
await liquidPledging.transfer(1, 1, utils.toWei(0.5), 2, { from: giver1 });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 2);
assert.equal(nPledges, 2);
const res1 = await liquidPledging.getPledge(1);
assert.equal(res1[0].toNumber(), web3.toWei(0.5));
assert.equal(res1[0], utils.toWei(0.5));
const res2 = await liquidPledging.getPledge(2);
assert.equal(res2[0].toNumber(), web3.toWei(0.5));
assert.equal(res2[1].toNumber(), 1); // One delegate
assert.equal(res2[0], utils.toWei(0.5));
assert.equal(res2[1], 1); // One delegate
const d = await liquidPledging.getPledgeDelegate(2, 1);
assert.equal(d[0], 2);
@ -132,77 +139,77 @@ describe('LiquidPledging test', () => {
assert.equal(res4[4], 0);
assert.equal(res4[5], false);
}).timeout(6000);
it('Delegate should assign to campaign2', async () => {
it('Delegate should assign to campaign1', async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.transfer(2, 2, web3.toWei(0.2), 3, { from: delegate1 });
await liquidPledging.transfer(2, 2, utils.toWei(0.2), 3, { from: delegate1 });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 3);
assert.equal(nPledges, 3);
const res3 = await liquidPledging.getPledge(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 Campaign
assert.isAbove(res3[4].toNumber(), n + 86000);
assert.equal(res3[5].toNumber(), 0); // Old Node
assert.equal(res3[6].toNumber(), 0); // Not Paid
assert.equal(res3[0], utils.toWei(0.2));
assert.equal(res3[1], 1); // Owner
assert.equal(res3[2], 1); // Delegates
assert.equal(res3[3], 3); // Proposed Campaign
assert.isAbove(utils.toDecimal(res3[4]), n + 86000);
assert.equal(res3[5], 0); // Old Node
assert.equal(res3[6], 0); // Not Paid
}).timeout(6000);
it('Giver should change his mind and assign half of it to campaign2', async () => {
await liquidPledging.transfer(1, 3, web3.toWei(0.1), 4, { from: giver1 });
await liquidPledging.transfer(1, 3, utils.toWei(0.1), 4, { from: giver1 });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 4);
assert.equal(nPledges, 4);
const res3 = await liquidPledging.getPledge(3);
assert.equal(res3[0].toNumber(), web3.toWei(0.1));
assert.equal(res3[0], utils.toWei(0.1));
const res4 = await liquidPledging.getPledge(4);
assert.equal(res4[1].toNumber(), 4); // Owner
assert.equal(res4[2].toNumber(), 0); // Delegates
assert.equal(res4[3].toNumber(), 0); // Proposed Campaign
assert.equal(res4[1], 4); // Owner
assert.equal(res4[2], 0); // Delegates
assert.equal(res4[3], 0); // Proposed Campaign
assert.equal(res4[4], 0);
assert.equal(res4[5].toNumber(), 2); // Old Node
assert.equal(res4[6].toNumber(), 0); // Not Paid
assert.equal(res4[5], 2); // Old Node
assert.equal(res4[6], 0); // Not Paid
}).timeout(6000);
it('After the time, the campaign1 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: adminCampaign1 });
await liquidPledging.withdraw(3, utils.toWei(0.05), { from: adminCampaign1 });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 6);
assert.equal(nPledges, 6);
const res5 = await liquidPledging.getPledge(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 Campaign
assert.equal(res5[0], utils.toWei(0.05));
assert.equal(res5[1], 3); // Owner
assert.equal(res5[2], 0); // Delegates
assert.equal(res5[3], 0); // Proposed Campaign
assert.equal(res5[4], 0); // commit time
assert.equal(res5[5].toNumber(), 2); // Old Node
assert.equal(res5[6].toNumber(), 0); // Not Paid
assert.equal(res5[5], 2); // Old Node
assert.equal(res5[6], 0); // Not Paid
const res6 = await liquidPledging.getPledge(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 Campaign
assert.equal(res6[0], utils.toWei(0.05));
assert.equal(res6[1], 3); // Owner
assert.equal(res6[2], 0); // Delegates
assert.equal(res6[3], 0); // Proposed Campaign
assert.equal(res6[4], 0); // commit time
assert.equal(res6[5].toNumber(), 2); // Old Node
assert.equal(res6[6].toNumber(), 1); // Peinding paid Paid
assert.equal(res6[5], 2); // Old Node
assert.equal(res6[6], 1); // Peinding paid Paid
}).timeout(6000);
it('Should collect the Ether', async () => {
const initialBalance = await getBalance(web3, adminCampaign1);
const initialBalance = await web3.eth.getBalance(adminCampaign1);
await vault.confirmPayment(0);
const finalBalance = await getBalance(web3, adminCampaign1);
const finalBalance = await web3.eth.getBalance(adminCampaign1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
const collected = utils.fromWei(utils.toBN(finalBalance).sub(utils.toBN(initialBalance)));
assert.equal(collected, 0.05);
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), 7);
assert.equal(nPledges, 7);
const res7 = await liquidPledging.getPledge(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 Campaign
assert.equal(res7[0], utils.toWei(0.05));
assert.equal(res7[1], 3); // Owner
assert.equal(res7[2], 0); // Delegates
assert.equal(res7[3], 0); // Proposed Campaign
assert.equal(res7[4], 0); // commit time
assert.equal(res7[5].toNumber(), 2); // Old Node
assert.equal(res7[6].toNumber(), 2); // Peinding paid Paid
assert.equal(res7[5], 2); // Old Node
assert.equal(res7[6], 2); // Peinding paid Paid
}).timeout(6000);
it('Admin of the campaign1 should be able to cancel campaign1', async () => {
await liquidPledging.cancelCampaign(3, { from: adminCampaign1 });
@ -211,29 +218,30 @@ describe('LiquidPledging test', () => {
}).timeout(6000);
it('Should not allow to withdraw from a canceled campaign', async () => {
const st = await liquidPledging.getState(liquidPledging);
assert.equal(web3.fromWei(st.pledges[5].amount).toNumber(), 0.05);
assert.equal(utils.fromWei(st.pledges[5].amount), 0.05);
await assertFail(async () => {
await liquidPledging.withdraw(5, web3.toWei(0.01), { from: adminCampaign1 });
await liquidPledging.withdraw(5, utils.toWei(0.01), { from: adminCampaign1 });
});
}).timeout(6000);
it('Delegate should send part of this ETH to campaign2', async () => {
await liquidPledging.transfer(2, 5, web3.toWei(0.03), 4,
{ $extraGas: 100000 },
{ from: delegate1 });
await liquidPledging.transfer(2, 5, utils.toWei(0.03), 4, {
$extraGas: 100000,
from: delegate1,
});
const st = await liquidPledging.getState(liquidPledging);
assert.equal(st.pledges.length, 9);
assert.equal(web3.fromWei(st.pledges[8].amount).toNumber(), 0.03);
assert.equal(utils.fromWei(st.pledges[8].amount), 0.03);
assert.equal(st.pledges[8].owner, 1);
assert.equal(st.pledges[8].delegates.length, 1);
assert.equal(st.pledges[8].delegates[0].id, 2);
assert.equal(st.pledges[8].proposedCampaign, 4);
}).timeout(6000);
it('Giver should be able to send the remaining to campaign2', async () => {
await liquidPledging.transfer(1, 5, web3.toWei(0.02), 4, { from: giver1 });
await liquidPledging.transfer(1, 5, utils.toWei(0.02), 4, { from: giver1, $extraGas: 100000 });
const st = await liquidPledging.getState(liquidPledging);
assert.equal(st.pledges.length, 9);
assert.equal(web3.fromWei(st.pledges[5].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.pledges[4].amount).toNumber(), 0.12);
assert.equal(utils.fromWei(st.pledges[5].amount), 0);
assert.equal(utils.fromWei(st.pledges[4].amount), 0.12);
}).timeout(6000);
it('A subcampaign 2a and a delegate2 is created', async () => {
await liquidPledging.addCampaign('Campaign2a', adminCampaign2a, 4, 86400, 0, { from: adminCampaign2 });
@ -242,28 +250,28 @@ describe('LiquidPledging test', () => {
assert.equal(nManagers, 6);
}).timeout(6000);
it('Campaign 2 delegate in delegate2', async () => {
await liquidPledging.transfer(4, 4, web3.toWei(0.02), 6, { from: adminCampaign2 });
await liquidPledging.transfer(4, 4, utils.toWei(0.02), 6, { from: adminCampaign2 });
const st = await liquidPledging.getState(liquidPledging);
assert.equal(st.pledges.length, 10);
assert.equal(web3.fromWei(st.pledges[9].amount).toNumber(), 0.02);
assert.equal(web3.fromWei(st.pledges[4].amount).toNumber(), 0.1);
assert.equal(utils.fromWei(st.pledges[9].amount), 0.02);
assert.equal(utils.fromWei(st.pledges[4].amount), 0.1);
}).timeout(6000);
it('delegate2 assigns to projec2a', async () => {
await liquidPledging.transfer(6, 9, web3.toWei(0.01), 5, { from: delegate2 });
await liquidPledging.transfer(6, 9, utils.toWei(0.01), 5, { from: delegate2 });
const st = await liquidPledging.getState(liquidPledging);
assert.equal(st.pledges.length, 11);
assert.equal(web3.fromWei(st.pledges[9].amount).toNumber(), 0.01);
assert.equal(web3.fromWei(st.pledges[10].amount).toNumber(), 0.01);
assert.equal(utils.fromWei(st.pledges[9].amount), 0.01);
assert.equal(utils.fromWei(st.pledges[10].amount), 0.01);
}).timeout(4000);
it('campaign2a authorize to spend a litle', async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.setMockedTime(n + (86401 * 3));
await liquidPledging.withdraw(10, web3.toWei(0.005), { from: adminCampaign2a });
await liquidPledging.withdraw(10, utils.toWei(0.005), { from: adminCampaign2a });
const st = await liquidPledging.getState(liquidPledging);
assert.equal(st.pledges.length, 13);
assert.equal(web3.fromWei(st.pledges[10].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.pledges[11].amount).toNumber(), 0.005);
assert.equal(web3.fromWei(st.pledges[12].amount).toNumber(), 0.005);
assert.equal(utils.fromWei(st.pledges[10].amount), 0);
assert.equal(utils.fromWei(st.pledges[11].amount), 0.005);
assert.equal(utils.fromWei(st.pledges[12].amount), 0.005);
}).timeout(4000);
it('campaign2 is canceled', async () => {
await liquidPledging.cancelCampaign(4, { from: adminCampaign2 });
@ -275,41 +283,42 @@ describe('LiquidPledging test', () => {
}).timeout(6000);
it('Should not be able to withdraw it', async () => {
await assertFail(async () => {
await liquidPledging.withdraw(12, web3.toWei(0.005), { from: giver1 });
await liquidPledging.withdraw(12, utils.toWei(0.005), { from: giver1 });
});
}).timeout(6000);
it('Should not be able to cancel payment', async () => {
await vault.cancelPayment(1);
const st = await liquidPledging.getState(liquidPledging);
it('Should be able to cancel payment', async () => {
// bug somewhere which will throw invalid op_code if we don't provide gas or extraGas
await vault.cancelPayment(1, { $extraGas: 100000 });
const st = await liquidPledging.getState();
assert.equal(st.pledges.length, 13);
assert.equal(web3.fromWei(st.pledges[2].amount).toNumber(), 0.31);
assert.equal(web3.fromWei(st.pledges[11].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.pledges[12].amount).toNumber(), 0);
assert.equal(utils.fromWei(st.pledges[2].amount), 0.31);
assert.equal(utils.fromWei(st.pledges[11].amount), 0);
assert.equal(utils.fromWei(st.pledges[12].amount), 0);
}).timeout(6000);
it('original owner should recover the remaining funds', async () => {
await liquidPledging.withdraw(1, web3.toWei(0.5), { from: giver1 });
await liquidPledging.withdraw(2, web3.toWei(0.31), { from: giver1 });
await liquidPledging.withdraw(4, web3.toWei(0.1), { from: giver1 });
await liquidPledging.withdraw(1, utils.toWei(0.5), { from: giver1 });
await liquidPledging.withdraw(2, utils.toWei(0.31), { from: giver1 });
await liquidPledging.withdraw(4, utils.toWei(0.1), { $extraGas: 100000, from: giver1 });
await liquidPledging.withdraw(8, web3.toWei(0.03), { $extraGas: 100000 }, { from: giver1 });
await liquidPledging.withdraw(9, web3.toWei(0.01), { from: giver1 });
await liquidPledging.withdraw(8, utils.toWei(0.03), { $extraGas: 100000, from: giver1 });
await liquidPledging.withdraw(9, utils.toWei(0.01), { $extraGas: 100000, from: giver1 });
const initialBalance = await getBalance(web3, giver1);
const initialBalance = await web3.eth.getBalance(giver1);
await vault.multiConfirm([2, 3, 4, 5, 6]);
const finalBalance = await getBalance(web3, giver1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
const finalBalance = await web3.eth.getBalance(giver1);
const collected = utils.fromWei(utils.toBN(finalBalance).sub(utils.toBN(initialBalance)));
assert.equal(collected, 0.95);
}).timeout(8000);
}).timeout(10000);
it('Should make a donation and create giver', async () => {
const oldNPledges = await liquidPledging.numberOfPledges();
const oldNManagers = await liquidPledging.numberOfPledgeManagers();
await liquidPledging.donate(0, 1, { from: giver2, value: web3.toWei(1) });
await liquidPledging.donate(0, 1, { from: giver2, value: utils.toWei(1) });
const nPledges = await liquidPledging.numberOfPledges();
assert.equal(nPledges.toNumber(), oldNPledges.toNumber() + 1);
assert.equal(utils.toDecimal(nPledges), utils.toDecimal(oldNPledges) + 1);
const nManagers = await liquidPledging.numberOfPledgeManagers();
assert.equal(nManagers.toNumber(), oldNManagers.toNumber() + 1);
assert.equal(utils.toDecimal(nManagers), utils.toDecimal(oldNManagers) + 1);
const res = await liquidPledging.getPledgeManager(nManagers);
assert.equal(res[0], 0); // Giver
assert.equal(res[1], giver2);