Add Reimbursement app

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, Reimbursement, Token }
+  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();

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, Reimbursement, Token }
+  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, Reimbursement, Token }
+  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/reimbursement/.gitattributes

@@ -0,0 +1 @@
+*.sol linguist-language=Solidity

apps/reimbursement/.gitignore

@@ -0,0 +1,7 @@
+node_modules
+artifacts
+.cache
+cache
+dist
+ipfs.cmd
+package-lock.json

apps/reimbursement/arapp.json

@@ -0,0 +1,34 @@
+{
+  "roles": [
+    {
+      "name": "Add reimursements",
+      "id": "ADD_REIMBURSEMENT_ROLE",
+      "params": []
+    },
+    {
+      "name": "Veto reimbursement",
+      "id": "VETO_REIMBURSEMENT_ROLE",
+      "params": []
+    }
+  ],
+  "environments": {
+    "default": {
+      "network": "development",
+      "appName": "kredits-reimbursement.open.aragonpm.eth"
+    },
+    "rinkeby": {
+      "registry": "0x98df287b6c145399aaa709692c8d308357bc085d",
+      "appName": "kredits-reimbursement.open.aragonpm.eth",
+      "wsRPC": "wss://rinkeby.eth.aragon.network/ws",
+      "network": "rinkeby"
+    },
+    "production": {
+      "registry": "0x314159265dd8dbb310642f98f50c066173c1259b",
+      "appName": "kredits-reimbursement.aragonpm.eth",
+      "wsRPC": "wss://mainnet.eth.aragon.network/ws",
+      "network": "mainnet"
+    }
+  },
+  "appName": "kredits-reimbursement.aragonpm.eth",
+  "path": "contracts/Reimbursement.sol"
+}

apps/reimbursement/buidler.config.js

@@ -0,0 +1,34 @@
+const { usePlugin } = require('@nomiclabs/buidler/config')
+const hooks = require('./scripts/buidler-hooks')
+
+usePlugin('@aragon/buidler-aragon')
+
+module.exports = {
+  // Default Buidler configurations. Read more about it at https://buidler.dev/config/
+  defaultNetwork: 'localhost',
+  networks: {
+    localhost: {
+      url: 'http://localhost:8545',
+    },
+  },
+  solc: {
+    version: '0.4.24',
+    optimizer: {
+      enabled: true,
+      runs: 10000,
+    },
+  },
+  // Etherscan plugin configuration. Learn more at https://github.com/nomiclabs/buidler/tree/master/packages/buidler-etherscan
+  etherscan: {
+    apiKey: '', // API Key for smart contract verification. Get yours at https://etherscan.io/apis
+  },
+  // Aragon plugin configuration
+  aragon: {
+    appServePort: 8001,
+    clientServePort: 3000,
+    appSrcPath: 'app/',
+    appBuildOutputPath: 'dist/',
+    appName: 'expenses',
+    hooks, // Path to script hooks
+  },
+}

apps/reimbursement/contracts/Reimbursement.sol

@@ -0,0 +1,119 @@
+pragma solidity ^0.4.24;
+
+import "@aragon/os/contracts/apps/AragonApp.sol";
+import "@aragon/os/contracts/kernel/IKernel.sol";
+
+contract Reimbursement is AragonApp {
+  bytes32 public constant ADD_REIMBURSEMENT_ROLE = keccak256("ADD_REIMBURSEMENT_ROLE");
+  bytes32 public constant VETO_REIMBURSEMENT_ROLE = keccak256("VETO_REIMBURSEMENT_ROLE");
+
+  bytes32 public constant KERNEL_APP_ADDR_NAMESPACE = 0xd6f028ca0e8edb4a8c9757ca4fdccab25fa1e0317da1188108f7d2dee14902fb;
+
+  // ensure alphabetic order
+  enum Apps { Contribution, Contributor, Proposal, Reimbursement, Token }
+  bytes32[5] public appIds;
+
+  struct ReimbursementData {
+    address recipient;
+    uint256 amount;
+    address token;
+    bool claimed;
+    bytes32 hashDigest;
+    uint8 hashFunction;
+    uint8 hashSize;
+    uint256 confirmedAtBlock;
+    bool vetoed;
+    bool exists;
+  }
+
+  mapping(uint32 => ReimbursementData) public reimbursements;
+  uint32 public reimbursementsCount;
+
+  uint32 public blocksToWait;
+
+  event ReimbursementAdded(uint32 id, address indexed addedByAccont, uint256 amount);
+  event ReimbursementClaimed(uint32 id, uint256 amount);
+  event ReimbursementVetoed(uint32 id, address vetoedByAccount);
+
+  function initialize(bytes32[5] _appIds) public onlyInit {
+    appIds = _appIds;
+    blocksToWait = 40320; // 7 days; 15 seconds block time
+    initialized();
+  }
+
+  function getContract(uint8 appId) public view returns (address) {
+    IKernel k = IKernel(kernel());
+    return k.getApp(KERNEL_APP_ADDR_NAMESPACE, appIds[appId]);
+  }
+
+  function totalAmount(bool confirmedOnly) public view returns (uint256 amount) {
+    for (uint32 i = 1; i <= reimbursementsCount; i++) {
+      ReimbursementData memory r = reimbursements[i];
+      if (!r.vetoed && (block.number >= r.confirmedAtBlock || !confirmedOnly)) {
+        amount += r.amount; // should use safemath
+      }
+    }
+  }
+
+  function getReimbursement(uint32 reimbursementId) public view returns (uint32 id, address recipient, uint256 amount, address token, bool claimed, bytes32 hashDigest, uint8 hashFunction, uint8 hashSize, uint256 confirmedAtBlock, bool exists, bool vetoed) {
+    id = reimbursementId;
+    ReimbursementData storage r = reimbursements[id];
+    return (
+      id,
+      r.recipient,
+      r.amount,
+      r.token,
+      r.claimed,
+      r.hashDigest,
+      r.hashFunction,
+      r.hashSize,
+      r.confirmedAtBlock,
+      r.exists,
+      r.vetoed
+    );
+  }
+
+  function add(uint256 amount, address token, bytes32 hashDigest, uint8 hashFunction, uint8 hashSize) public isInitialized auth(ADD_REIMBURSEMENT_ROLE) {
+    uint32 reimbursementId = reimbursementsCount + 1;
+    ReimbursementData storage r = reimbursements[reimbursementId];
+    r.exists = true;
+    r.amount = amount;
+    r.token = token;
+    r.claimed = false;
+    r.hashDigest = hashDigest;
+    r.hashFunction = hashFunction;
+    r.hashSize = hashSize;
+    r.confirmedAtBlock = block.number + blocksToWait;
+
+    reimbursementsCount++;
+
+    emit ReimbursementAdded(reimbursementId, msg.sender, amount);
+  }
+
+  function veto(uint32 reimbursementId) public isInitialized auth(VETO_REIMBURSEMENT_ROLE) {
+    ReimbursementData storage r = reimbursements[reimbursementId];
+    require(r.exists, 'NOT_FOUND');
+    require(!r.claimed, 'ALREADY_CLAIMED');
+    require(block.number < r.confirmedAtBlock, 'VETO_PERIOD_ENDED');
+    r.vetoed = true;
+
+    emit ReimbursementVetoed(reimbursementId, msg.sender);
+  }
+
+  function claim(uint32 reimbursementId) public isInitialized {
+    ReimbursementData storage r = reimbursements[reimbursementId];
+    require(r.exists, 'NOT_FOUND');
+    require(!r.claimed, 'ALREADY_CLAIMED');
+    require(!r.vetoed, 'VETOED');
+    require(block.number >= r.confirmedAtBlock, 'NOT_CLAIMABLE');
+
+    r.claimed = true;
+    // TODO
+    // transfer using vault
+    emit ReimbursementClaimed(reimbursementId, r.amount);
+  }
+
+  function exists(uint32 reimbursementId) public view returns (bool) {
+    return reimbursements[reimbursementId].exists;
+  }
+}

apps/reimbursement/manifest.json

@@ -0,0 +1,16 @@
+{
+  "name": "kredits Reimbursement",
+  "author": "Placeholder-author",
+  "description": "An application for Aragon",
+  "details_url": "/meta/details.md",
+  "source_url": "https://<placeholder-repository-url>",
+  "icons": [
+    {
+      "src": "/meta/icon.svg",
+      "sizes": "56x56"
+    }
+  ],
+  "screenshots": [{ "src": "/meta/screenshot-1.png" }],
+  "start_url": "/index.html",
+  "script": "/script.js"
+}

apps/reimbursement/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "kredits-reimbursement",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "start": "npm run start:aragon:ipfs",
+    "start:aragon:ipfs": "aragon run",
+    "start:aragon:http": "aragon run --http localhost:8001 --http-served-from ./dist",
+    "start:app": "",
+    "compile": "aragon contracts compile",
+    "sync-assets": "",
+    "build:app": "",
+    "build:script": "",
+    "build": "",
+    "publish:patch": "aragon apm publish patch",
+    "publish:minor": "aragon apm publish minor",
+    "publish:major": "aragon apm publish major",
+    "versions": "aragon apm versions",
+    "test": "truffle test"
+  },
+  "dependencies": {
+    "@aragon/os": "^4.4.0"
+  },
+  "devDependencies": {
+    "@aragon/test-helpers": "^2.1.0",
+    "eth-gas-reporter": "^0.2.17",
+    "ganache-cli": "^6.9.1",
+    "solidity-coverage": "^0.5.11"
+  }
+}

apps/reimbursement/test/helpers/dao.js

@@ -0,0 +1,61 @@
+const { hash } = require('eth-ens-namehash')
+const { getEventArgument } = require('@aragon/contract-test-helpers/events')
+const Kernel = artifacts.require('@aragon/os/build/contracts/kernel/Kernel')
+const ACL = artifacts.require('@aragon/os/build/contracts/acl/ACL')
+const EVMScriptRegistryFactory = artifacts.require(
+  '@aragon/os/build/contracts/factory/EVMScriptRegistryFactory'
+)
+const DAOFactory = artifacts.require(
+  '@aragon/os/build/contracts/factory/DAOFactory'
+)
+
+const newDao = async (rootAccount) => {
+  // Deploy a DAOFactory.
+  const kernelBase = await Kernel.new(true)
+  const aclBase = await ACL.new()
+  const registryFactory = await EVMScriptRegistryFactory.new()
+  const daoFactory = await DAOFactory.new(
+    kernelBase.address,
+    aclBase.address,
+    registryFactory.address
+  )
+
+  // Create a DAO instance.
+  const daoReceipt = await daoFactory.newDAO(rootAccount)
+  const dao = await Kernel.at(getEventArgument(daoReceipt, 'DeployDAO', 'dao'))
+
+  // Grant the rootAccount address permission to install apps in the DAO.
+  const acl = await ACL.at(await dao.acl())
+  const APP_MANAGER_ROLE = await kernelBase.APP_MANAGER_ROLE()
+  await acl.createPermission(
+    rootAccount,
+    dao.address,
+    APP_MANAGER_ROLE,
+    rootAccount,
+    { from: rootAccount }
+  )
+
+  return { dao, acl }
+}
+
+const newApp = async (dao, appName, baseAppAddress, rootAccount) => {
+  const receipt = await dao.newAppInstance(
+    hash(`${appName}.aragonpm.test`), // appId - Unique identifier for each app installed in the DAO; can be any bytes32 string in the tests.
+    baseAppAddress, // appBase - Location of the app's base implementation.
+    '0x', // initializePayload - Used to instantiate and initialize the proxy in the same call (if given a non-empty bytes string).
+    false, // setDefault - Whether the app proxy is the default proxy.
+    { from: rootAccount }
+  )
+
+  // Find the deployed proxy address in the tx logs.
+  const logs = receipt.logs
+  const log = logs.find((l) => l.event === 'NewAppProxy')
+  const proxyAddress = log.args.proxy
+
+  return proxyAddress
+}
+
+module.exports = {
+  newDao,
+  newApp,
+}

apps/reimbursement/test/helpers/permissions.js

@@ -0,0 +1,17 @@
+const ANY_ADDRESS = '0xffffffffffffffffffffffffffffffffffffffff'
+
+const setOpenPermission = async (acl, appAddress, role, rootAddress) => {
+  // Note: Setting a permission to 0xffffffffffffffffffffffffffffffffffffffff
+  // is interpreted by aragonOS as allowing the role for any address.
+  await acl.createPermission(
+    ANY_ADDRESS, // entity (who?) - The entity or address that will have the permission.
+    appAddress, // app (where?) - The app that holds the role involved in this permission.
+    role, // role (what?) - The particular role that the entity is being assigned to in this permission.
+    rootAddress, // manager - Can grant/revoke further permissions for this role.
+    { from: rootAddress}
+  )
+}
+
+module.exports = {
+  setOpenPermission
+}

apps/reimbursement/truffle.js

@@ -0,0 +1 @@
+module.exports = require("../../truffle.js");

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, Reimbursement, Token }
+  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';