fix typo

.github/release-drafter.yml

@@ -1,4 +0,0 @@
-template: |
-  ## Changes
-
-  $CHANGES

.travis.yml

@@ -15,26 +15,19 @@ cache:
     - apps/token/node_modules
     - apps/vault/node_modules
 
-env:
-  - TASK=lint:wrapper
-  - TASK=lint:contract-tests
-  - TASK=test:token
-  - TASK=test:contributor
-  - TASK=test:contribution
-  - TASK=test:proposal
-
 install:
   - npm install -g @aragon/cli
   - npm install -g truffle
   - npm install
 
 before_script:
-  - npm run devchain > /dev/null &
-  - sleep 5
+  - npm run devchain &
 
 script:
-  - travis_wait 60 npm run $TASK
+  - npm run lint:wrapper
+  - npm run lint:contract-tests
+  - npm run test
 
 branches:
   only:
-    - master
+    - master

apps/contribution/contracts/Contribution.sol

@@ -21,8 +21,8 @@ contract Contribution is AragonApp {
   bytes32 public constant KERNEL_APP_ADDR_NAMESPACE = 0xd6f028ca0e8edb4a8c9757ca4fdccab25fa1e0317da1188108f7d2dee14902fb;
 
   // ensure alphabetic order
-  enum Apps { Contribution, Contributor, Proposal, Token }
-  bytes32[4] public appIds;
+  enum Apps { Contribution, Contributor, Proposal, Token, Vault }
+  bytes32[5] public appIds;
 
   struct ContributionData {
     uint32 contributorId;
@@ -54,7 +54,7 @@ contract Contribution is AragonApp {
   event ContributionClaimed(uint32 id, uint32 indexed contributorId, uint32 amount);
   event ContributionVetoed(uint32 id, address vetoedByAccount);
 
-  function initialize(bytes32[4] _appIds) public onlyInit {
+  function initialize(bytes32[5] _appIds) public onlyInit {
     appIds = _appIds;
     blocksToWait = 40320; // 7 days; 15 seconds block time
     initialized();
@@ -152,8 +152,6 @@ contract Contribution is AragonApp {
 
   function add(uint32 amount, uint32 contributorId, bytes32 hashDigest, uint8 hashFunction, uint8 hashSize) public isInitialized auth(ADD_CONTRIBUTION_ROLE) {
     //require(canPerform(msg.sender, ADD_CONTRIBUTION_ROLE, new uint32[](0)), 'nope');
-    require(amount > 0, "INVALID_AMOUNT");
-
     uint32 contributionId = contributionsCount + 1;
     ContributionData storage c = contributions[contributionId];
     c.exists = true;

apps/contribution/test/app.js

@@ -0,0 +1,5 @@
+// const Contribution = artifacts.require('Contribution.sol');
+
+contract('Contribution', (_accounts) => {
+  it('should be tested');
+});

apps/contribution/test/contribution.js

@@ -1,332 +0,0 @@
-const namehash = require('ethers').utils.namehash;
-// eslint-disable-next-line no-undef
-const Contribution = artifacts.require("Contribution.sol");
-// eslint-disable-next-line no-undef
-const Contributor = artifacts.require("Contributor.sol");
-// eslint-disable-next-line no-undef
-const Token = artifacts.require("Token.sol");
-
-// eslint-disable-next-line no-undef
-const getContract = name => artifacts.require(name);
-const { assertRevert } = require('@aragon/test-helpers/assertThrow');
-const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
-
-const timeTravel = function(time){
-  return new Promise((resolve, reject) => {
-    // eslint-disable-next-line no-undef
-    web3.currentProvider.sendAsync({
-      jsonrpc: "2.0",
-      method: "evm_increaseTime",
-      params: [time], //86400 is num seconds in day
-      id: new Date().getSeconds(),
-    }, (err, result) => {
-      if(err) {
-        return reject(err);
-      }
-      return resolve(result);
-    });
-  });
-};
-
-const mineBlock = function() {
-  return new Promise((resolve, reject) => {
-    // eslint-disable-next-line no-undef
-    web3.currentProvider.sendAsync({
-      jsonrpc: "2.0",
-      method: "evm_mine",
-      params: [],
-      id: new Date().getSeconds(),
-    }, (err, result) => {
-      if(err){ return reject(err); }
-      return resolve(result);
-    });
-  });
-};
-
-const getBlockNumber = function() {
-  return new Promise((resolve, reject) => {
-    // eslint-disable-next-line no-undef
-    web3.eth.getBlockNumber(async (err, res) => {
-      if (err || !res) return reject(err);
-      resolve(res);
-    });
-  });
-};
-
-contract('Contribution app', (accounts) => {
-  // eslint-disable-next-line no-undef
-  let kernelBase, aclBase, daoFactory, r, dao, acl, contribution, token, contributor;
-
-  const root = accounts[0];
-  const member1 = accounts[1];
-  const blocksToWait = 40320;
-
-  // eslint-disable-next-line no-undef
-  before(async () => {
-    kernelBase = await getContract('Kernel').new(true); // petrify immediately
-    aclBase = await getContract('ACL').new();
-    daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
-    r = await daoFactory.newDAO(root);
-    dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
-    acl = getContract('ACL').at(await dao.acl());
-
-    //create dao mamnager permission for coin owner
-    await acl.createPermission(
-      root,
-      dao.address,
-      await dao.APP_MANAGER_ROLE(),
-      root,
-      { from: root }
-    );
-
-    //apps id
-    let appsId = [];
-    appsId[0] = namehash("kredits-contribution");
-    appsId[1] = namehash("kredits-contributor");
-    appsId[2] = namehash("kredits-proposal");
-    appsId[3] = namehash("kredits-token");
-
-    //get new app instance from DAO
-    let receipt = await dao.newAppInstance(
-      appsId[0],
-      (await Contribution.new()).address,
-      0x0,
-      false,
-      { from: root }
-    );
-    contribution = Contribution.at(
-      receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
-    );
-
-    receipt = await dao.newAppInstance(
-      appsId[3],
-      (await Token.new()).address,
-      0x0,
-      false,
-      { from: root }
-    );
-    token = Token.at(
-      receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
-    );
-
-    receipt = await dao.newAppInstance(
-      appsId[1],
-      (await Contributor.new()).address,
-      0x0,
-      false,
-      { from: root }
-    );
-    contributor = Contributor.at(
-      receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
-    );
-
-    //init app
-    await contribution.initialize(appsId);
-
-    await acl.createPermission(
-      root,
-      contribution.address,
-      await contribution.ADD_CONTRIBUTION_ROLE(),
-      root,
-      { from: root }
-    );
-
-    await acl.createPermission(
-      root,
-      contribution.address,
-      await contribution.VETO_CONTRIBUTION_ROLE(),
-      root,
-      { from: root }
-    );
-
-    //init token (app)
-    await token.initialize(appsId);
-
-    //create token mint permission for coin owner
-    await acl.createPermission(
-      contribution.address,
-      token.address,
-      await token.MINT_TOKEN_ROLE(),
-      root,
-      { from: root }
-    );
-
-    //init contributor app
-    await contributor.initialize(root, appsId);
-
-    await acl.createPermission(
-      root,
-      contributor.address,
-      await contributor.MANAGE_CONTRIBUTORS_ROLE(),
-      root,
-      { from: root }
-    );
-  });
-
-  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);
-    });
-
-    it('check contribution app can mint token', async () => {
-      let mintTokenPermission = await acl.hasPermission(contribution.address, token.address, await token.MINT_TOKEN_ROLE());
-      // eslint-disable-next-line no-undef
-      assert.equal(mintTokenPermission, true);
-    });
-
-  });
-
-  describe("Add contribution", async () => {
-    // contributor detials
-    let account, contributorHashDigest, contributorHashFunction, contributorHashSize;
-    // contribution details
-    let amount, contributorId, hashDigest, hashFunction, hashSize;
-
-    // eslint-disable-next-line no-undef
-    before(async () => {
-      // Add contributor from Contributor app
-      account = root;
-      contributorHashDigest = '0x0000000000000000000000000000000000000000000000000000000000000000';
-      contributorHashFunction = 0;
-      contributorHashSize = 0;
-      await contributor.addContributor(account, contributorHashDigest, contributorHashFunction, contributorHashSize);
-      // eslint-disable-next-line no-undef
-      assert.equal(await contributor.addressExists(account), true);
-
-      amount = 100;
-      contributorId = await contributor.getContributorIdByAddress(root);
-      hashDigest = '0x0000000000000000000000000000000000000000000000000000000000000000';
-      hashFunction = 1;
-      hashSize = 1;  
-    });
-
-    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';
-      });
-    });
-
-    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';
-      });
-    });
-
-    it("should add contribution", async () => {
-      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, "contributions counter incremented");
-      let contributionObject = await contribution.getContribution(contributionCountAfter.toNumber());
-      // eslint-disable-next-line no-undef
-      assert.equal(contributionObject[1].toNumber(), contributorId.toNumber(), "contribution added belong to contributor id");
-      let isExist = await contribution.exists(contributionCountAfter.toNumber());
-      // eslint-disable-next-line no-undef
-      assert.equal(isExist, true, "contribution exist");
-    });
-  });
-
-  describe("Veto contribution", async () => {
-    it("should revert when veto from address that does not have permission", async () => {
-      const contributionId = await contribution.contributionsCount();
-      return assertRevert(async () => {
-        await contribution.veto(contributionId.toNumber(), {from: member1});
-        'sender does not have permission to veto';
-      });
-    });
-
-    it("should revert when veto contribution that does not exist", async () => {
-      const contributionId = await contribution.contributionsCount();
-      return assertRevert(async () => {
-        await contribution.veto(contributionId.toNumber()+1, {from: root});
-        'contribution not found';
-      });
-    });
-
-    it("veto contribution", async () => {
-      const contributionId = await contribution.contributionsCount();
-      if(contributionId < 10) {
-        return assertRevert(async () => {
-          await contribution.veto(contributionId.toNumber(), {from: root});
-          'can not veto first 10 contribution';
-        });  
-      }
-      else {
-        await contribution.veto(contributionId.toNumber(), {from: root});
-        let contributionObject = await contribution.getContribution(contributionId.toNumber());
-        // eslint-disable-next-line no-undef
-        assert(contributionObject[9], true);  
-      }
-    });
-  });
-
-  describe("Claim contribution", async () => {
-    let contributionId;
-
-    // eslint-disable-next-line no-undef
-    before(async () =>{
-      //add contribution
-      let amount = 200;
-      let contributorId = await contributor.getContributorIdByAddress(root);
-      let contributionHashDigest = '0x0000000000000000000000000000000000000000000000000000000000000000';
-      let contributionHashFunction = 1;
-      let contributionHashSize = 1;
-      await contribution.add(amount, contributorId.toNumber(), contributionHashDigest, contributionHashFunction, contributionHashSize, {from: root});
-      contributionId = await contribution.contributionsCount();
-    });
-
-    it("should revert when claim contribution that does not exist", async () => {
-      return assertRevert(async () => {
-        await contribution.claim(contributionId.toNumber()+1, {from: root});
-        'contribution not found';
-      });
-    });
-
-    it("should revert when claim contribution before confirmation block", async () => {
-      if(contributionId > 10) {
-        return assertRevert(async () => {
-          await contribution.claim(contributionId.toNumber(), {from: root});
-          'contribution not confirmed yet';
-        });
-      }
-    });
-
-    it("claim contribution", async () => {
-      let contributionObject = await contribution.getContribution(contributionId.toNumber());
-      let confirmationBlock = contributionObject[7];
-      let chainBlockNumberBefore = await getBlockNumber();
-
-      if(contributionId > 10) {
-        await timeTravel(blocksToWait);
-        await mineBlock();
-        let chainBlockNumberAfter = await getBlockNumber();
-        // eslint-disable-next-line no-undef
-        assert.equal(chainBlockNumberAfter.toNumber()-chainBlockNumberBefore.toNumber(), confirmationBlock.toNumber());
-      }
-      //Claim contribution
-      await contribution.claim(contributionId, {from: root});
-      contributionObject = await contribution.getContribution(contributionId.toNumber());
-      // eslint-disable-next-line no-undef
-      assert(contributionObject[3], true);
-    });
-
-    it("should revert when claim already claimed contribution", async () => {
-      return assertRevert(async () => {
-        await contribution.claim(contributionId.toNumber(), {from: root});
-        'contribution already claimed';
-      });
-    });
-
-  });
-});

apps/contributor/contracts/Contributor.sol

@@ -28,14 +28,14 @@ contract Contributor is AragonApp {
   uint32 public contributorsCount;
 
   // ensure alphabetic order
-  enum Apps { Contribution, Contributor, Proposal, Token }
-  bytes32[4] public appIds;
+  enum Apps { Contribution, Contributor, Proposal, Token, Vault }
+  bytes32[5] public appIds;
 
   event ContributorProfileUpdated(uint32 id, bytes32 oldHashDigest, bytes32 newHashDigest); // what should be logged
   event ContributorAccountUpdated(uint32 id, address oldAccount, address newAccount);
   event ContributorAdded(uint32 id, address account);
 
-  function initialize(address root,bytes32[4] _appIds) public onlyInit {
+  function initialize(address root, bytes32[5] _appIds) public onlyInit {
     appIds = _appIds;
 
     initialized();

apps/proposal/contracts/Proposal.sol

@@ -20,8 +20,8 @@ contract Proposal is AragonApp {
 
   bytes32 public constant KERNEL_APP_ADDR_NAMESPACE = 0xd6f028ca0e8edb4a8c9757ca4fdccab25fa1e0317da1188108f7d2dee14902fb;
   // ensure alphabetic order
-  enum Apps { Contribution, Contributor, Proposal, Token }
-  bytes32[4] public appIds;
+  enum Apps { Contribution, Contributor, Proposal, Token, Vault }
+  bytes32[5] public appIds;
 
   struct Proposal {
     address creatorAccount;
@@ -46,7 +46,7 @@ contract Proposal is AragonApp {
   event ProposalVoted(uint32 id, uint32 voterId, uint16 totalVotes);
   event ProposalExecuted(uint32 id, uint32 contributorId, uint32 amount);
 
-  function initialize(bytes32[4] _appIds) public onlyInit {
+  function initialize(bytes32[5] _appIds) public onlyInit {
     appIds = _appIds;
     initialized();
   }

apps/token/contracts/Token.sol

@@ -7,12 +7,12 @@ contract Token is ERC20Token, AragonApp {
   bytes32 public constant MINT_TOKEN_ROLE = keccak256("MINT_TOKEN_ROLE");
 
   // ensure alphabetic order
-  enum Apps { Contribution, Contributor, Proposal, Token }
-  bytes32[4] public appIds;
+  enum Apps { Contribution, Contributor, Proposal, Token, Vault }
+  bytes32[5] public appIds;
 
   event LogMint(address indexed recipient, uint256 amount, uint32 contributionId);
 
-  function initialize(bytes32[4] _appIds) public onlyInit {
+  function initialize(bytes32[5] _appIds) public onlyInit {
     appIds = _appIds;
     name = 'Kredits';
     symbol = '₭S';

arapp.json

@@ -34,9 +34,7 @@
   "environments": {
     "development": {
       "network": "development",
-      "apm": {
-        "open.aragonpm.eth"
-      },
+      "apm": "open.aragonpm.eth",
       "registry": "0x5f6f7e8cc7346a11ca2def8f827b7a0b612c56a1",
       "appName": "dummy.open.aragonpm.eth"
     },
@@ -46,9 +44,7 @@
       "wsRPC": "wss://rinkeby.eth.aragon.network/ws",
       "daoFactory": "0x2298d27a9b847c681d2b2c2828ab9d79013f5f1d",
       "appName": "dummy.open.aragonpm.eth",
-      "apm": {
-        "open.aragonpm.eth"
-      }
+      "apm": "open.aragonpm.eth"
     },
     "kovan": {
       "network": "kovan",
@@ -57,9 +53,7 @@
     "default": {
       "network": "development",
       "appName": "dummy.aragonpm.eth",
-      "apm": {
-        "open.aragonpm.eth"
-      }
+      "apm": "open.aragonpm.eth"
     }
   },
   "path": "contracts/misc/DummyApp.sol"

contracts/KreditsKit.sol

@@ -6,6 +6,8 @@ import "@aragon/os/contracts/acl/ACL.sol";
 
 import "@aragon/kits-base/contracts/KitBase.sol";
 
+import "@aragon/apps-vault/contracts/Vault.sol";
+
 import "../apps/contribution/contracts/Contribution.sol";
 import "../apps/contributor/contracts/Contributor.sol";
 import "../apps/token/contracts/Token.sol";
@@ -14,13 +16,13 @@ import "../apps/proposal/contracts/Proposal.sol";
 contract KreditsKit is KitBase  {
 
     // ensure alphabetic order
-    enum Apps { Contribution, Contributor, Proposal, Token }
-    bytes32[4] public appIds;
+    enum Apps { Contribution, Contributor, Proposal, Token, Vault }
+    bytes32[5] public appIds;
 
     event DeployInstance(address dao);
     event InstalledApp(address dao, address appProxy, bytes32 appId);
 
-    constructor (DAOFactory _fac, ENS _ens, bytes32[4] _appIds) public KitBase(_fac, _ens) {
+    constructor (DAOFactory _fac, ENS _ens, bytes32[5] _appIds) public KitBase(_fac, _ens) {
       appIds = _appIds;
     }
 
@@ -44,6 +46,9 @@ contract KreditsKit is KitBase  {
         Proposal proposal = Proposal(_installApp(dao, appIds[uint8(Apps.Proposal)]));
         proposal.initialize(appIds);
 
+        Vault vault = Vault(_installApp(dao, appIds[uint8(Apps.Vault)]));
+        vault.initialize();
+
         acl.createPermission(root, contribution, contribution.ADD_CONTRIBUTION_ROLE(), this);
         acl.createPermission(root, contribution, contribution.VETO_CONTRIBUTION_ROLE(), this);
         acl.grantPermission(proposal, contribution, contribution.ADD_CONTRIBUTION_ROLE());
@@ -72,6 +77,10 @@ contract KreditsKit is KitBase  {
         acl.grantPermission(contribution, token, token.MINT_TOKEN_ROLE());
         acl.setPermissionManager(root, token, token.MINT_TOKEN_ROLE());
 
+        // Vault permissions
+        acl.createPermission(root, vault, vault.TRANSFER_ROLE(), this);
+        //TODO: grant rewards app permission to transfer funds
+        //acl.grantPermission(rewards, vault, vault.TRANSFER_ROLE());
 
         cleanupDAOPermissions(dao, acl, root);
 

contracts/test/Spoof.sol

@@ -3,8 +3,6 @@ pragma solidity ^0.4.24;
 import "@aragon/os/contracts/acl/ACL.sol";
 import "@aragon/os/contracts/kernel/Kernel.sol";
 import "@aragon/os/contracts/factory/DAOFactory.sol";
-import "../../../contributor/contracts/Contributor.sol";
-import "../../../token/contracts/Token.sol";
 
 // You might think this file is a bit odd, but let me explain.
 // We only use for now those imported contracts in our tests, which
@@ -15,4 +13,4 @@ import "../../../token/contracts/Token.sol";
 // solium-disable-next-line no-empty-blocks
 contract Spoof {
   // ...
-}
+}

lib/serializers/contributor.js

@@ -28,7 +28,7 @@ class Contributor {
       github_username,
       gitea_username,
       wiki_username,
-      zoom_display_name,
+      accounts,
     } = this;
 
     let data = {
@@ -36,7 +36,7 @@ class Contributor {
       '@type': 'Contributor',
       kind,
       name,
-      accounts: [],
+      accounts: accounts || [],
     };
 
     if (url) {
@@ -68,13 +68,6 @@ class Contributor {
       });
     }
 
-    if (zoom_display_name) {
-      data.accounts.push({
-        'site': 'zoom.us',
-        'username': zoom_display_name,
-      });
-    }
-
     // Write it pretty to ipfs
     return JSON.stringify(data, null, 2);
   }
@@ -104,11 +97,10 @@ class Contributor {
       accounts,
     } = JSON.parse(serialized.toString('utf8'));
 
-    let github_username, github_uid, gitea_username, wiki_username, zoom_display_name;
+    let github_username, github_uid, gitea_username, wiki_username;
     let github = accounts.find(a => a.site === 'github.com');
     let gitea  = accounts.find(a => a.site === 'gitea.kosmos.org');
     let wiki   = accounts.find(a => a.site === 'wiki.kosmos.org');
-    let zoom   = accounts.find(a => a.site === 'zoom.us');
 
     if (github) {
       (({ username: github_username, uid: github_uid} = github));
@@ -119,9 +111,6 @@ class Contributor {
     if (wiki) {
       (({ username: wiki_username } = wiki));
     }
-    if (zoom) {
-      (({ username: zoom_display_name } = zoom));
-    }
 
     return {
       name,
@@ -132,7 +121,6 @@ class Contributor {
       github_username,
       gitea_username,
       wiki_username,
-      zoom_display_name,
       ipfsData: serialized,
     };
   }

package.json

@@ -24,11 +24,12 @@
     "lint:contracts": "solhint \"contracts/**/*.sol\" \"apps/*/contracts/**/*.sol\"",
     "lint:contract-tests": "eslint apps/*/test",
     "lint:wrapper": "eslint lib/",
-    "test": "npm run test:token && npm run test:contributor && npm run test:contribution && npm run test:proposal",
+    "test": "npm run test:token && npm run test:contributor && npm run test:contribution && npm run test:proposal && npm run test:kit",
     "test:token": "cd apps/token && npm run test",
     "test:contributor": "cd apps/contributor && npm run test",
     "test:contribution": "cd apps/contribution && npm run test",
     "test:proposal": "cd apps/proposal && npm run test",
+    "test:kit": "aragon contracts test",
     "setup-git-hooks": "sh scripts/git-hooks/install"
   },
   "repository": {
@@ -44,7 +45,6 @@
   "devDependencies": {
     "@aragon/kits-base": "^1.0.0",
     "@aragon/os": "^4.2.0",
-    "@aragon/test-helpers": "^2.0.0",
     "async-each-series": "^1.1.0",
     "cli-table": "^0.3.1",
     "eslint": "^5.16.0",
@@ -58,6 +58,7 @@
     "yargs": "^12.0.0"
   },
   "dependencies": {
+    "@aragon/apps-vault": "^4.1.0",
     "ethers": "^4.0.29",
     "ipfs-http-client": "^30.1.3",
     "kosmos-schemas": "^2.1.0",

test/kreditskit.js

@@ -0,0 +1,95 @@
+/* eslint-disable no-undef */
+const namehash = require('ethers').utils.namehash;
+const KreditsKit = artifacts.require("KreditsKit.sol");
+const getContract = name => artifacts.require(name);
+const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
+const arapp = require('../arapp.json');
+const ENS_ADDRESS = arapp.environments.development.registry;
+
+contract('DAO bare kit', (accounts) => {
+  let kreditsKit;
+  let address;
+  let apps;
+  let kernel;
+  let contribution;
+  let contributor;
+  let proposal;
+  let token;
+  let vault;
+
+  before(async () => {
+    //apps id
+    const appsId = [];
+    appsId[0] = namehash("kredits-contribution");
+    appsId[1] = namehash("kredits-contributor");
+    appsId[2] = namehash("kredits-proposal");
+    appsId[3] = namehash("kredits-token");
+    appsId[4] = namehash("vault");
+
+    const kernelBase = await getContract('Kernel').new(true); // petrify immediately
+    const aclBase = await getContract('ACL').new();
+    const daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
+    
+    kreditsKit = await KreditsKit.new(ZERO_ADDR, ENS_ADDRESS, appsId, { from: accounts[0] });
+  });
+
+  describe("New DAO instance", () => {
+    it("kit should be defined", async () => {
+      assert.notEqual(kreditsKit, undefined);
+    });
+
+    it('it should deploy DAO', async () => {
+      const receipt = await kreditsKit.newInstance({ from: accounts[0] });
+
+      address = receipt.logs.filter(l => l.event === 'DeployInstance')[0].args.dao;
+      apps = receipt.logs
+        .filter(l => l.event === 'InstalledApp')
+        .map(event => {
+          return { id: event.args.appId, proxy: event.args.appProxy };
+        });
+
+      address.should.not.equal(ZERO_ADDR);
+    });
+
+    it('it should install apps', async () => {
+      apps[0].id.should.equal(namehash('kredits-contribution'));
+      apps[1].id.should.equal(namehash('kredits-contributor'));
+      apps[0].id.should.equal(namehash('kredits-proposal'));
+      apps[1].id.should.equal(namehash('kredits-token'));
+      apps[0].id.should.equal(namehash('vault'));
+    });
+
+    it('it should initialize apps', async () => {
+      contribution = await getContract('Contribution').at(apps[0].proxy);
+      contributor = await getContract('Contributor').at(apps[1].proxy);
+      proposal = await getContract('Proposal').at(apps[2].proxy);
+      token = await getContract('Token').at(apps[3].proxy);
+      vault = await getContract('Vault').at(apps[4].proxy);
+      (await Promise.all([
+        contribution.hasInitialized(),
+        contributor.hasInitialized(),
+        proposal.hasInitialized(),
+        token.hasInitialized(),
+        vault.hasInitialized(),
+      ])).should.deep.equal([true, true, true, true, true]);
+    });
+
+    it('it should set permissions', async () => {
+      kernel = await getContract('Kernel').at(address);
+      (await Promise.all([
+        //check contribution app roles
+        kernel.hasPermission(accounts[0], contribution.address, await space.ADD_CONTRIBUTION_ROLE(), '0x0'),
+        kernel.hasPermission(accounts[0], contribution.address, await space.VETO_CONTRIBUTION_ROLE(), '0x0'),
+        kernel.hasPermission(proposal.address, contribution.address, await space.ADD_CONTRIBUTION_ROLE(), '0x0'),
+        //proposal app roles
+        kernel.hasPermission(accounts[0], proposal.address, await proposal.VOTE_PROPOSAL_ROLE(), '0x0'),
+        //token app roles
+        kernel.hasPermission(accounts[0], token.address, await token.MINT_TOKEN_ROLE(), '0x0'),
+        kernel.hasPermission(contribution.address, token.address, await token.MINT_TOKEN_ROLE(), '0x0'),
+        //vaul app roles
+        kernel.hasPermission(accounts[0], vault.address, await vault.TRANSFER_ROLE(), '0x0'),
+      ])).should.deep.equal([true, true, true, true, true, true, true]);
+    });
+
+  });
+});