lint fix

apps/contribution/test/contribution.js

@@ -1,26 +1,29 @@
 const namehash = require('eth-ens-namehash').hash;
 
+// eslint-disable-next-line no-undef
 const Contribution = artifacts.require("Contribution.sol");
 const { Token, getTokenContract } = require("../../token/artifacts");
 
-const getContract = name => artifacts.require(name)
+// eslint-disable-next-line no-undef
+const getContract = name => artifacts.require(name);
 const { assertRevert } = require('@aragon/test-helpers/assertThrow');
 
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
 
 contract('Contribution app', (accounts) => {
-    let kernelBase, aclBase, daoFactory, dao, acl, contribution, token;
+    let kernelBase, aclBase, daoFactory, r, dao, acl, contribution, token;
   
     const root = accounts[0];
     const member1 = accounts[1];
 
+    // eslint-disable-next-line no-undef
     before(async () => {
-        kernelBase = await getContract('Kernel').new(true) // petrify immediately
+        kernelBase = await getContract('Kernel').new(true); // petrify immediately
-        aclBase = await getContract('ACL').new()
+        aclBase = await getContract('ACL').new();
         daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
-        r = await daoFactory.newDAO(root)
+        r = await daoFactory.newDAO(root);
-        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao)
+        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
-        acl = getContract('ACL').at(await dao.acl())
+        acl = getContract('ACL').at(await dao.acl());
     
         //create dao mamnager permission for coin owner
         await acl.createPermission(
@@ -46,7 +49,7 @@ contract('Contribution app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         contribution = Contribution.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
         );
@@ -57,7 +60,7 @@ contract('Contribution app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         token = Token.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
         );
@@ -71,7 +74,7 @@ contract('Contribution app', (accounts) => {
             await contribution.ADD_CONTRIBUTION_ROLE(),
             root,
             { from: root }
-        )
+        );
 
         await acl.createPermission(
             root,
@@ -99,11 +102,13 @@ contract('Contribution app', (accounts) => {
     describe("Owner default space permissions", async () => {
         it('check owner can add contribution', async () => {
           let addContributionPermission = await acl.hasPermission(root, contribution.address, await contribution.ADD_CONTRIBUTION_ROLE());
+          // eslint-disable-next-line no-undef
           assert.equal(addContributionPermission, true);
         });  
 
         it('check owner can veto contribution', async () => {
             let vetoContributionPermission = await acl.hasPermission(root, contribution.address, await contribution.VETO_CONTRIBUTION_ROLE());
+            // eslint-disable-next-line no-undef
             assert.equal(vetoContributionPermission, true);
         });  
     });
@@ -118,14 +123,14 @@ contract('Contribution app', (accounts) => {
         it("should revert when add contribution from address that does not have permission", async () => {
             return assertRevert(async () => {
                 await contribution.add(amount, contributorId, hashDigest, hashFunction, hashSize, {from: member1});
-              'sender does not have permission'
+              'sender does not have permission';
             });
         });
 
         it("should revert when add contribution with amount equal to zero", async () => {
             return assertRevert(async () => {
                 await contribution.add(0, contributorId, hashDigest, hashFunction, hashSize, {from: root});
-              'amount equal to zero'
+              'amount equal to zero';
             });
         });
 
@@ -133,10 +138,13 @@ contract('Contribution app', (accounts) => {
             let contributionCountBefore = await contribution.contributionsCount();
             await contribution.add(amount, contributorId, hashDigest, hashFunction, hashSize, {from: root});
             let contributionCountAfter = await contribution.contributionsCount();
+            // eslint-disable-next-line no-undef
             assert.equal(contributionCountAfter.toNumber()-contributionCountBefore.toNumber(), 1);
             let contributionObject = await contribution.getContribution(contributionCountAfter.toNumber());
+            // eslint-disable-next-line no-undef
             assert.equal(contributionObject[1], contributorId);
             let isExist = await contribution.exists(contributionCountAfter.toNumber());
+            // eslint-disable-next-line no-undef
             assert.equal(isExist, true);
         });
     });
@@ -147,7 +155,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             return assertRevert(async () => {
                 await contribution.veto(contributionId.toNumber(), {from: member1});
-              'sender does not have permission to veto'
+              'sender does not have permission to veto';
             });
         });
 
@@ -155,7 +163,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             return assertRevert(async () => {
                 await contribution.veto(contributionId.toNumber()+1, {from: root});
-              'contribution not found'
+              'contribution not found';
             });
         });
 
@@ -163,7 +171,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             return assertRevert(async () => {
                 await contribution.claim(contributionId.toNumber()+1, {from: root});
-              'contribution not found'
+              'contribution not found';
             });
         });
 
@@ -171,6 +179,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             await contribution.claim(contributionId);
             let contributionObject = await contribution.getContribution(contributionId.toNumber());
+            // eslint-disable-next-line no-undef
             assert(contributionObject[3], true);
         });
 
@@ -178,7 +187,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             return assertRevert(async () => {
                 await contribution.claim(contributionId.toNumber(), {from: root});
-              'contribution already claimed'
+              'contribution already claimed';
             });
         });
 
@@ -186,7 +195,7 @@ contract('Contribution app', (accounts) => {
             let contributionId = await contribution.contributionsCount();
             return assertRevert(async () => {
                 await contribution.veto(contributionId.toNumber(), {from: root});
-              'contribution already claimed'
+              'contribution already claimed';
             });
         });
 

apps/contributor/test/contributor.js

@@ -1,25 +1,28 @@
 const namehash = require('eth-ens-namehash').hash;
 
+// eslint-disable-next-line no-undef
 const Contributor = artifacts.require("Contributor.sol");
 
-const getContract = name => artifacts.require(name)
+// eslint-disable-next-line no-undef
+const getContract = name => artifacts.require(name);
 const { assertRevert } = require('@aragon/test-helpers/assertThrow');
 
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
 
 contract('Contributor app', (accounts) => {
-    let kernelBase, aclBase, daoFactory, dao, acl, contributor;
+    let kernelBase, aclBase, daoFactory, r, dao, acl, contributor;
   
     const root = accounts[0];
     const member1 = accounts[1];
   
+    // eslint-disable-next-line no-undef
     before(async () => {
-        kernelBase = await getContract('Kernel').new(true) // petrify immediately
+        kernelBase = await getContract('Kernel').new(true); // petrify immediately
-        aclBase = await getContract('ACL').new()
+        aclBase = await getContract('ACL').new();
         daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
-        r = await daoFactory.newDAO(root)
+        r = await daoFactory.newDAO(root);
-        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao)
+        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
-        acl = getContract('ACL').at(await dao.acl())
+        acl = getContract('ACL').at(await dao.acl());
     
         //create dao mamnager permission for coin owner
         await acl.createPermission(
@@ -37,10 +40,10 @@ contract('Contributor app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         contributor = Contributor.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
-        )
+        );
 
         //apps id
         let appsId = [];
@@ -59,13 +62,14 @@ contract('Contributor app', (accounts) => {
             await contributor.MANAGE_CONTRIBUTORS_ROLE(),
             root,
             { from: root }
-        )
+        );
     
     });
 
     describe("Owner default space permissions", async () => {
         it('check owner is token issuer', async () => {
           let manageContributorPermission = await acl.hasPermission(root, contributor.address, await contributor.MANAGE_CONTRIBUTORS_ROLE());
+          // eslint-disable-next-line no-undef
           assert.equal(manageContributorPermission, true);
         });  
     });
@@ -78,23 +82,25 @@ contract('Contributor app', (accounts) => {
 
         it("should revert when add contributor from an address that does not have permission", async () => {
             return assertRevert(async () => {
-              await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1})
+              await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
-              'sender does not have permission'
+              'sender does not have permission';
             });
         });
 
         it('add contributor', async () => {
             let contributorCount = await contributor.coreContributorsCount();
             await contributor.addContributor(account, hashDigest, hashFunction, hashSize);
+            // eslint-disable-next-line no-undef
             assert.equal(await contributor.addressExists(account), true);
             let contributorCountAfter = await contributor.coreContributorsCount();
+            // eslint-disable-next-line no-undef
             assert.equal(await contributorCountAfter.toNumber(), parseInt(contributorCount)+1);
         });
 
         it("should revert when add contributor with an address that already exist", async () => {
             return assertRevert(async () => {
-              await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1})
+              await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
-              'address already exist'
+              'address already exist';
             });
         });
     });
@@ -107,6 +113,7 @@ contract('Contributor app', (accounts) => {
         let hashFunction;
         let hashSize;
 
+        // eslint-disable-next-line no-undef
         before(async () =>  {
             id = await contributor.coreContributorsCount();
             oldAccount = root;
@@ -119,42 +126,43 @@ contract('Contributor app', (accounts) => {
         it('update contributor account', async () => {
             await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount);
             let contributorId = await contributor.getContributorIdByAddress(oldAccount);
+            // eslint-disable-next-line no-undef
             assert.equal(contributorId.toNumber(), 0);
         });
 
         it("should revert when update contributor account from address that does not have permission", async () => {
             return assertRevert(async () => {
                 await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount, {from: member1});
-              'sender does not have permission'
+              'sender does not have permission';
             });
         });
 
         it("should revert when update contributor account that does not exist", async () => {
             return assertRevert(async () => {
               await contributor.updateContributorAccount(id.toNumber(), accounts[3], newAccount);
-              'contributor does not exist'
+              'contributor does not exist';
             });
         });
 
         it("should revert when update contributor account with address(0)", async () => {
             return assertRevert(async () => {
               await contributor.updateContributorAccount(id.toNumber(), oldAccount, ZERO_ADDR);
-              'contributor does not exist'
+              'contributor does not exist';
             });
         });
 
         it('update contributor profile hash', async () => {
             await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize);
             let contributorProfile = await contributor.contributors(id.toNumber());
-            assert.equal(hashDigest, contributorProfile[1]);
+            assert.equal(hashDigest, contributorProfile[1]);    // eslint-disable-line no-undef
-            assert.equal(hashFunction, contributorProfile[2].toNumber());
+            assert.equal(hashFunction, contributorProfile[2].toNumber());   // eslint-disable-line no-undef
-            assert.equal(hashSize, contributorProfile[3].toNumber());
+            assert.equal(hashSize, contributorProfile[3].toNumber());   // eslint-disable-line no-undef
         });
 
         it("should revert when update contributor profile hash from address that does not have permission", async () => {
             return assertRevert(async () => {
                 await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize, {from: member1});
-                'sender does not have permission'
+                'sender does not have permission';
             });
         });
 

apps/proposal/test/proposal.js

@@ -1,27 +1,30 @@
 const namehash = require('eth-ens-namehash').hash;
 
+// eslint-disable-next-line no-undef
 const Proposal = artifacts.require("Proposal.sol");
 const { Contributor, getContributorContract } = require("../../contributor/artifacts");
 const { Contribution, getContributionContract } = require("../../contribution/artifacts");
 
-const getContract = name => artifacts.require(name)
+// eslint-disable-next-line no-undef
+const getContract = name => artifacts.require(name);
+// eslint-disable-next-line no-unused-vars
 const { assertRevert } = require('@aragon/test-helpers/assertThrow');
 
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
 
 contract('Proposal app', (accounts) => {
-    let kernelBase, aclBase, daoFactory, dao, acl, proposal, contribution, contributor;
+    let kernelBase, aclBase, daoFactory, dao, r, acl, proposal, contribution, contributor;
   
     const root = accounts[0];
-    const member1 = accounts[1];
 
+    // eslint-disable-next-line no-undef
     before(async () => {
-        kernelBase = await getContract('Kernel').new(true) // petrify immediately
+        kernelBase = await getContract('Kernel').new(true); // petrify immediately
-        aclBase = await getContract('ACL').new()
+        aclBase = await getContract('ACL').new();
         daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
-        r = await daoFactory.newDAO(root)
+        r = await daoFactory.newDAO(root);
-        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao)
+        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
-        acl = getContract('ACL').at(await dao.acl())
+        acl = getContract('ACL').at(await dao.acl());
     
         //create dao mamnager permission for coin owner
         await acl.createPermission(
@@ -47,7 +50,7 @@ contract('Proposal app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         proposal = Proposal.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
         );
@@ -58,7 +61,7 @@ contract('Proposal app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         contributor = Contributor.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
         );
@@ -69,7 +72,7 @@ contract('Proposal app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         contribution = Contribution.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
         );
@@ -83,7 +86,7 @@ contract('Proposal app', (accounts) => {
             await proposal.ADD_PROPOSAL_ROLE(),
             root,
             { from: root }
-        )
+        );
 
         await acl.createPermission(
             root,
@@ -102,7 +105,7 @@ contract('Proposal app', (accounts) => {
             await contribution.ADD_CONTRIBUTION_ROLE(),
             root,
             { from: root }
-        )
+        );
 
         await acl.createPermission(
             root,
@@ -123,32 +126,37 @@ contract('Proposal app', (accounts) => {
             await contributor.MANAGE_CONTRIBUTORS_ROLE(),
             root,
             { from: root }
-        )
+        );
     });
 
     describe("Owner default permissions", async () => {
         it('check owner can add proposal', async () => {
           let addProposalPermission = await acl.hasPermission(root, proposal.address, await proposal.ADD_PROPOSAL_ROLE());
+          // eslint-disable-next-line no-undef
           assert.equal(addProposalPermission, true);
         });  
 
         it('check owner can veto contribution', async () => {
             let vetoProposalPermission = await acl.hasPermission(root, proposal.address, await proposal.VOTE_PROPOSAL_ROLE());
+            // eslint-disable-next-line no-undef
             assert.equal(vetoProposalPermission, true);
         });  
 
         it('check owner can add contribution', async () => {
             let addContributionPermission = await acl.hasPermission(root, contribution.address, await contribution.ADD_CONTRIBUTION_ROLE());
+            // eslint-disable-next-line no-undef
             assert.equal(addContributionPermission, true);
         });   
 
         it('check owner can veto contribution', async () => {
             let vetoContributionPermission = await acl.hasPermission(root, contribution.address, await contribution.VETO_CONTRIBUTION_ROLE());
+            // eslint-disable-next-line no-undef
             assert.equal(vetoContributionPermission, true);
         });  
 
         it('check owner can manage contributors', async () => {
             let manageContributorsPermission = await acl.hasPermission(root, contributor.address, await contribution.MANAGE_CONTRIBUTORS_ROLE());
+            // eslint-disable-next-line no-undef
             assert.equal(manageContributorsPermission, true);
         });  
     });

apps/token/test/token.js

@@ -1,25 +1,28 @@
 const namehash = require('eth-ens-namehash').hash;
 
+// eslint-disable-next-line no-undef
 const Token = artifacts.require("Token.sol");
 
-const getContract = name => artifacts.require(name)
+// eslint-disable-next-line no-undef
+const getContract = name => artifacts.require(name);
 const { assertRevert } = require('@aragon/test-helpers/assertThrow');
 
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
 
 contract('Token app', (accounts) => {
-    let kernelBase, aclBase, daoFactory, dao, acl, token;
+    let kernelBase, aclBase, daoFactory, dao, r, acl, token;
   
     const root = accounts[0];
     const member1 = accounts[1];
   
+    // eslint-disable-next-line no-undef
     before(async () => {
-        kernelBase = await getContract('Kernel').new(true) // petrify immediately
+        kernelBase = await getContract('Kernel').new(true); // petrify immediately
-        aclBase = await getContract('ACL').new()
+        aclBase = await getContract('ACL').new();
         daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
-        r = await daoFactory.newDAO(root)
+        r = await daoFactory.newDAO(root);
-        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao)
+        dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
-        acl = getContract('ACL').at(await dao.acl())
+        acl = getContract('ACL').at(await dao.acl());
     
         //create dao mamnager permission for coin owner
         await acl.createPermission(
@@ -37,10 +40,10 @@ contract('Token app', (accounts) => {
             0x0,
             false,
             { from: root }
-        )
+        );
         token = Token.at(
             receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
-        )
+        );
 
         //apps id
         let appsId = [];
@@ -59,13 +62,14 @@ contract('Token app', (accounts) => {
             await token.MINT_TOKEN_ROLE(),
             root,
             { from: root }
-        )
+        );
     
     });
 
     describe("Owner default space permissions", async () => {
         it('check owner is token issuer', async () => {
           let tokenIssuerPermission = await acl.hasPermission(root, token.address, await token.MINT_TOKEN_ROLE());
+          // eslint-disable-next-line no-undef
           assert.equal(tokenIssuerPermission, true);
         });  
     });
@@ -76,9 +80,9 @@ contract('Token app', (accounts) => {
         let decimals = 18;
   
         it("check token properties", async () => {
-          assert.equal(await token.name(), name);
+          assert.equal(await token.name(), name); // eslint-disable-line no-undef
-          assert.equal(await token.symbol(), symbol);
+          assert.equal(await token.symbol(), symbol); // eslint-disable-line no-undef
-          assert.equal(await token.decimals(), decimals);
+          assert.equal(await token.decimals(), decimals); // eslint-disable-line no-undef
         });
   
     });
@@ -89,22 +93,22 @@ contract('Token app', (accounts) => {
   
         it("should revert when mint tokens from an address that does not have minting permission", async () => {
           return assertRevert(async () => {
-            await token.mintFor(root, tokenToMint, 1, { from: member1})
+            await token.mintFor(root, tokenToMint, 1, { from: member1});
-            'address does not have permission to mint tokens'
+            'address does not have permission to mint tokens';
           });
         });
   
         it("should revert when mint tokens to address(0)", async () => {
           return assertRevert(async () => {
-            await token.mintFor(ZERO_ADDR, tokenToMint, 1, { from: root})
+            await token.mintFor(ZERO_ADDR, tokenToMint, 1, { from: root});
-            'invalid contributor address'
+            'invalid contributor address';
           });
         });
   
         it("should revert when mint amount of tokens equal to 0", async () => {
           return assertRevert(async () => {
-            await token.mintFor(root, 0, 1, { from: root})
+            await token.mintFor(root, 0, 1, { from: root});
-            'amount to mint should be greater than zero'
+            'amount to mint should be greater than zero';
           });
         });
   
@@ -112,8 +116,8 @@ contract('Token app', (accounts) => {
           await token.mintFor(root, tokenToMint, 1, { from: root });
           let ownerBalance = await token.balanceOf(root);
           let totalSupply = await token.totalSupply();
-          assert.equal(ownerBalance.toNumber(), tokenToMint*ether);
+          assert.equal(ownerBalance.toNumber(), tokenToMint*ether); // eslint-disable-line no-undef
-          assert.equal(totalSupply.toNumber(), tokenToMint*ether);
+          assert.equal(totalSupply.toNumber(), tokenToMint*ether);  // eslint-disable-line no-undef
+        });
     });
 });
-})

lib/kredits.js

@@ -1,5 +1,4 @@
 const ethers = require('ethers');
-const RSVP = require('rsvp');
 
 const Preflight = require('./utils/preflight');
 const deprecate = require('./utils/deprecate');