kredits/contracts
kredits/contracts
9
1
Fork 0
Code Issues 21 Pull Requests Actions Projects 1 Releases 8 Activity

WIP: Install aragon vault app into Kredits kit #173

Closed
haythem96 wants to merge 5 commits from kit/add-vault-app into master
pull from: kit/add-vault-app
merge into: kredits:master
Conversation 8 Commits 5 Files Changed 9 +268 -447
9 changed files with 268 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
apps/contribution/contracts/Contribution.sol
View File

@ -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();

6
apps/contributor/contracts/Contributor.sol
View File

@ -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();

6
apps/proposal/contracts/Proposal.sol
View File

@ -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();
}

6
apps/token/contracts/Token.sol
View File

@ -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';

15
contracts/KreditsKit.sol
View File

@ -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);

16
contracts/test/Spoof.sol Normal file
View File

@ -0,0 +1,16 @@
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";
// 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
// means Truffle will not compile them for us, because they are from
// an external dependency.
// solium-disable-next-line no-empty-blocks
contract Spoof {
// ...
}

561
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

4
package.json
View File

@ -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": {
@ -57,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",

95
test/kreditskit.js Normal file
View File

@ -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]);
});
});
});