refactor contrats with aragonos

apps/contributor/.gitignore

@@ -0,0 +1,4 @@
+node_modules
+build
+.cache
+dist

apps/contributor/.ipfsignore

@@ -0,0 +1,14 @@
+# Git files
+.gitignore
+
+# Build files
+.cache
+node_modules
+build
+
+# Lock files
+package-lock.json
+yarn.lock
+
+# Others
+test

apps/contributor/README.md

@@ -0,0 +1,162 @@
+# Aragon React Boilerplate
+
+> 🕵️ [Find more boilerplates using GitHub](https://github.com/search?q=topic:aragon-boilerplate) | 
+> ✨ [Official boilerplates](https://github.com/search?q=topic:aragon-boilerplate+org:aragon)
+
+React boilerplate for Aragon applications.
+
+This boilerplate also includes a fully working example app, complete with a background worker and a front-end in React (with Aragon UI).
+
+## Usage
+
+```sh
+aragon init app.aragonpm.eth react
+```
+
+## Running your app
+
+### Using HTTP
+
+Running your app using HTTP will allow for a faster development process of your app's front-end, as it can be hot-reloaded without the need to execute `aragon run` every time a change is made.
+
+- First start your app's development server running `npm run start:app`, and keep that process running. By default it will rebuild the app and reload the server when changes to the source are made.
+
+- After that, you can run `npm run start:aragon:http` which will compile your app's contracts, publish the app locally and create a DAO. You will need to stop it and run it again after making changes to your smart contracts.
+
+Changes to the app's background script (`app/script.js`) cannot be hot-reloaded, after making changes to the script, you will need to either restart the development server (`npm run start:app`) or rebuild the script `npm run build:script`.
+
+### Using IPFS
+
+Running your app using IPFS will mimic the production environment that will be used for running your app. `npm run start:aragon:ipfs` will run your app using IPFS. Whenever a change is made to any file in your front-end, a new version of the app needs to be published, so the command needs to be restarted.
+
+## What's in the box?
+
+### npm Scripts
+
+- **start** or **start:aragon:ipfs**: Runs your app inside a DAO served from IPFS
+- **start:aragon:http**: Runs your app inside a DAO served with HTTP (hot reloading)
+- **start:app**: Starts a development server for your app
+- **compile**: Compile the smart contracts
+- **build**: Builds the front-end and background script
+- **build:app**: Builds the front-end
+- **build:script**: Builds the background script
+- **test**: Runs tests for the contracts
+- **publish:patch**: Release a patch version to aragonPM (only frontend/content changes allowed)
+- **publish:minor**: Release a minor version to aragonPM (only frontend/content changes allowed)
+- **publish:major**: Release a major version to aragonPM (frontend **and** contract changes)
+- **versions**: Check the currently installed versions of the app
+
+### Libraries
+
+- [**@aragon/os**](https://github.com/aragon/aragonos): Aragon interfaces
+- [**@aragon/client**](https://github.com/aragon/aragon.js/tree/master/packages/aragon-client): Wrapper for Aragon application RPC
+- [**@aragon/ui**](https://github.com/aragon/aragon-ui): Aragon UI components (in React)
+
+## Publish
+
+This app has 3 environments defined in `arapp.json`:
+
+| Environment   | Network   |
+|---            |---        |
+| default       | localhost |
+| staging       | rinkeby   |
+| production    | mainnet   |
+
+Prerequisites:
+- ENS Registry address
+
+Note: the `default` environment which points to `localhost` does not have an ENS Registry address specified because the `@aragon/cli` will default the value to `0xB9462EF3441346dBc6E49236Edbb0dF207db09B7` (the ENS Registry pre-deployed on the local development chain).
+
+### Introduction to environments
+
+Environments are defined in `arapp.json`, for example `staging` points to:
+- an ENS registry (`0x314159265dd8dbb310642f98f50c066173c1259b`)
+- an APM registry (`open.aragonpm.eth`)
+- an APM repository (`app`)
+- an Ethereum network (`rinkeby`)
+- an Ethereum websockets provider (`wss://rinkeby.eth.aragon.network/ws` - to **read** from the blockchain)
+
+The `rinkeby` network is further defined in `truffle.js`, and has:
+- an Ethereum provider (to **write** to the blockchain):
+    - an address (`https://rinkeby.infura.io`)
+    - an Ethereum Account (`0xb4124cEB3451635DAcedd11767f004d8a28c6eE7`)
+    (which is the first account generated from the `DEFAULT_MNEMONIC` variable, to use a different account see [here](#Using-a-different-Ethereum-account))
+
+### Major version: content + contract
+
+Command:
+```
+npm run publish:major -- --environment staging
+```
+
+This will:
+1. _build_ the app's frontend (the output lives in `dist`)
+2. _compile_ the app's contract (the output lives in `build`)
+3. publish the app to the **staging** environment.
+
+Sample output:
+```
+ > aragon apm publish major "--environment" "staging"
+
+ ✔ Successfully published app.open.aragonpm.eth v1.0.0: 
+ ℹ Contract address: 0xE636bcA5B95e94F749F63E322a04DB59362299F1
+ ℹ Content (ipfs): QmR695Wu5KrHNec7pRP3kPvwYihABDAyVYdX5D5vwLgxCn
+ ℹ Transaction hash: 0x3d752db29cc106e9ff98b260a90615921eb32471425a29ead8cbb830fb224d8
+```
+
+Note: the contract location is defined in `arapp.json` under `path`.
+Note: you can also deploy a major version with only frontend changes by passing `--only-content`.
+
+### Minor/patch version: content only
+
+Command:
+```
+npm run publish:patch -- --environment staging
+```
+
+This will:
+1. _build_ the app's frontend (which lives in `dist`)
+2. publish the app to the **staging** environment.
+
+Sample output:
+```
+ ✔ Successfully published app.open.aragonpm.eth v1.1.1: 
+ ℹ Contract address: 0xE636bcA5B95e94F749F63E322a04DB59362299F1
+ ℹ Content (ipfs): QmUYv9cjyNVxCyAJGK2YXjkbzh6u4iW2ak81Z9obdefM1q
+ ℹ Transaction hash: 0x57864d8efd8d439008621b494b19a3e8f876a8a46b38475f9626802f0a1403c2
+```
+
+### Check published versions
+
+Command:
+```
+npm run versions -- --environment staging
+```
+
+Sample output:
+```
+ ℹ app.open.aragonpm.eth has 4 published versions
+ ✔ 1.0.0: 0xE636bcA5B95e94F749F63E322a04DB59362299F1 ipfs:QmR695Wu5KrHNec7pRP3kPvwYihABDAyVYdX5D5vwLgxCn
+ ✔ 1.1.0: 0xE636bcA5B95e94F749F63E322a04DB59362299F1 ipfs:QmSwjUZFpv2c2e9fLoxtgFrAsAmBN4DyQGJp4RcqQcW3z3
+ ✔ 1.1.1: 0xE636bcA5B95e94F749F63E322a04DB59362299F1 ipfs:QmUYv9cjyNVxCyAJGK2YXjkbzh6u4iW2ak81Z9obdefM1q
+ ✔ 2.0.0: 0x74CBbbC932d7C344FCd789Eba24BfD40e52980c9 ipfs:Qmadb3hzwLDKtb93fF367Vg1epkdsLZF4dhpapNYynjgZF
+```
+
+### Using a different Ethereum account
+
+To deploy from a different account, you can:
+- define a `~/.aragon/mnemonic.json` file
+    ```
+    {
+        "mnemonic": "explain tackle mirror kit ..."
+    }
+    ```
+    or
+- define a `~/.aragon/${network_name}_key.json` file, for example: `~/.aragon/rinkeby_key.json`
+    ```
+    {
+        "keys": [
+            "a8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563"
+        ]
+    }
+    ```

apps/contributor/arapp.json

@@ -0,0 +1,28 @@
+{
+  "roles": [
+    {
+      "name": "Manage contributors",
+      "id": "MANAGE_CONTRIBUTORS_ROLE",
+      "params": []
+    }
+  ],
+  "environments": {
+    "default": {
+      "network": "development",
+      "appName": "contributor.aragonpm.eth"
+    },
+    "staging": {
+      "registry": "0x98df287b6c145399aaa709692c8d308357bc085d",
+      "appName": "contributor.open.aragonpm.eth",
+      "wsRPC": "wss://rinkeby.eth.aragon.network/ws",
+      "network": "rinkeby"
+    },
+    "production": {
+      "registry": "0x314159265dd8dbb310642f98f50c066173c1259b",
+      "appName": "contributor.open.aragonpm.eth",
+      "wsRPC": "wss://mainnet.eth.aragon.network/ws",
+      "network": "mainnet"
+    }
+  },
+  "path": "contracts/Contributor.sol"
+}

apps/contributor/contracts/Contributor.sol

@@ -0,0 +1,124 @@
+pragma solidity ^0.4.24;
+
+import "@aragon/os/contracts/apps/AragonApp.sol";
+
+contract Contributor is AragonApp {
+  bytes32 public constant MANAGE_CONTRIBUTORS_ROLE = keccak256("MANAGE_CONTRIBUTORS_ROLE");
+
+  struct Contributor {
+    address account;
+    bytes32 ipfsHash;
+    uint8 hashFunction;
+    uint8 hashSize;
+    bool isCore;
+    bool exists;
+  }
+
+  mapping (address => uint) public contributorIds;
+  mapping (uint => Contributor) public contributors;
+  uint256 public contributorsCount;
+
+  event ContributorProfileUpdated(uint id, bytes32 oldIpfsHash, bytes32 newIpfsHash);
+  event ContributorAccountUpdated(uint id, address oldAccount, address newAccount);
+  event ContributorAdded(uint id, address account);
+
+  function initialize(address root) public onlyInit {
+    uint _id = contributorsCount + 1;
+    Contributor storage c = contributors[_id];
+    c.exists = true;
+    c.isCore = true;
+    c.account = root;
+    contributorIds[root] = _id;
+    contributorsCount += 1;
+
+    initialized();
+  }
+
+  function coreContributorsCount() view public returns (uint) {
+    uint count = 0;
+    for (uint256 i = 1; i <= contributorsCount; i++) {
+      if (contributors[i].isCore) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+
+  function updateContributorAccount(uint id, address oldAccount, address newAccount) public auth(MANAGE_CONTRIBUTORS_ROLE) {
+    contributorIds[oldAccount] = 0;
+    contributorIds[newAccount] = id;
+    contributors[id].account = newAccount;
+    ContributorAccountUpdated(id, oldAccount, newAccount);
+  }
+
+  function updateContributorIpfsHash(uint id, bytes32 ipfsHash, uint8 hashFunction, uint8 hashSize) public isInitialized auth(MANAGE_CONTRIBUTORS_ROLE) {
+    Contributor storage c = contributors[id];
+    bytes32 oldIpfsHash = c.ipfsHash;
+    c.ipfsHash = ipfsHash;
+    c.hashFunction = hashFunction;
+    c.hashSize = hashSize;
+
+    ContributorProfileUpdated(id, oldIpfsHash, c.ipfsHash);
+  }
+
+  function addContributor(address account, bytes32 ipfsHash, uint8 hashFunction, uint8 hashSize, bool isCore) public isInitialized auth(MANAGE_CONTRIBUTORS_ROLE) {
+    require(!addressExists(account));
+    uint _id = contributorsCount + 1;
+    assert(!contributors[_id].exists); // this can not be acually
+    Contributor storage c = contributors[_id];
+    c.exists = true;
+    c.isCore = isCore;
+    c.ipfsHash = ipfsHash;
+    c.hashFunction = hashFunction;
+    c.hashSize = hashSize;
+    c.account = account;
+    contributorIds[account] = _id;
+
+    contributorsCount += 1;
+    emit ContributorAdded(_id, account);
+  }
+
+  function isCore(uint id) view public returns (bool) {
+    return contributors[id].isCore;
+  }
+
+  function exists(uint id) view public returns (bool) {
+    return contributors[id].exists;
+  }
+
+  function addressIsCore(address account) view public returns (bool) {
+    return getContributorByAddress(account).isCore;
+  }
+
+  function addressExists(address account) view public returns (bool) {
+    return getContributorByAddress(account).exists;
+  }
+
+  function getContributorIdByAddress(address account) view public returns (uint) {
+    return contributorIds[account];
+  }
+
+  function getContributorAddressById(uint id) view public returns (address) {
+    return contributors[id].account;
+  }
+
+  function getContributorByAddress(address account) internal view returns (Contributor) {
+    uint id = contributorIds[account];
+    return contributors[id];
+  }
+
+  function getContributorById(uint _id) public view returns (uint id, address account, bytes32 ipfsHash, uint8 hashFunction, uint8 hashSize, bool isCore, bool exists ) {
+    id = _id;
+    Contributor storage c = contributors[_id];
+    account = c.account;
+    ipfsHash = c.ipfsHash;
+    hashFunction = c.hashFunction;
+    hashSize = c.hashSize;
+    isCore = c.isCore;
+    exists = c.exists;
+  }
+
+  function canPerform(address _who, address _where, bytes32 _what, uint256[] _how) public view returns (bool) {
+    return addressExists(_who);
+  }
+}

apps/contributor/contracts/misc/Migrations.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.4.4;
+
+contract Migrations {
+  address public owner;
+  uint public last_completed_migration;
+
+  modifier restricted() {
+    if (msg.sender == owner) _;
+  }
+
+  function Migrations() {
+    owner = msg.sender;
+  }
+
+  function setCompleted(uint completed) restricted {
+    last_completed_migration = completed;
+  }
+
+  function upgrade(address new_address) restricted {
+    Migrations upgraded = Migrations(new_address);
+    upgraded.setCompleted(last_completed_migration);
+  }
+}

apps/contributor/manifest.json

@@ -0,0 +1,4 @@
+{
+  "name": "Contributor",
+  "description": "Kredits Contributor app"
+}

apps/contributor/migrations/1_initial_migration.js

@@ -0,0 +1,5 @@
+var Migrations = artifacts.require('./Migrations.sol')
+
+module.exports = function (deployer) {
+  deployer.deploy(Migrations)
+}

apps/contributor/migrations/2_deploy_contracts.js

@@ -0,0 +1,5 @@
+var Contributor = artifacts.require('Contributor.sol')
+
+module.exports = function (deployer) {
+  deployer.deploy(Contributor)
+}

apps/contributor/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "kredits-contributor",
+  "version": "1.0.0",
+  "description": "",
+  "dependencies": {
+    "@aragon/os": "^4.1.0",
+    "@aragon/cli": "^5.5.0"
+  },
+  "devDependencies": {},
+  "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": "",
+    "test": "aragon contracts test",
+    "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"
+  },
+  "keywords": []
+}

apps/contributor/test/app.js

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

apps/contributor/truffle.js

@@ -0,0 +1,63 @@
+/**
+ * https://github.com/aragon/aragonOS/blob/v4.0.0/truffle-config.js
+ */
+const homedir = require('homedir')
+const path = require('path')
+
+const HDWalletProvider = require('truffle-hdwallet-provider')
+const HDWalletProviderPrivkey = require('truffle-hdwallet-provider-privkey')
+
+const DEFAULT_MNEMONIC = 'explain tackle mirror kit van hammer degree position ginger unfair soup bonus'
+
+const defaultRPC = (network) =>
+  `https://${network}.infura.io`
+
+const configFilePath = (filename) =>
+  path.join(homedir(), `.aragon/${filename}`)
+
+const mnemonic = () => {
+  try {
+    return require(configFilePath('mnemonic.json')).mnemonic
+  } catch (e) {
+    return DEFAULT_MNEMONIC
+  }
+}
+
+const settingsForNetwork = (network) => {
+  try {
+    return require(configFilePath(`${network}_key.json`))
+  } catch (e) {
+    return { }
+  }
+}
+
+// Lazily loaded provider
+const providerForNetwork = (network) => (
+  () => {
+    let { rpc, keys } = settingsForNetwork(network)
+    rpc = rpc || defaultRPC(network)
+
+    if (!keys || keys.length == 0) {
+      return new HDWalletProvider(mnemonic(), rpc)
+    }
+
+    return new HDWalletProviderPrivkey(keys, rpc)
+  }
+)
+module.exports = {
+  networks: {
+    development: {
+      host: 'localhost',
+      port: 8545,
+      network_id: '*'
+    },
+    mainnet: {
+      network_id: 1,
+      provider: providerForNetwork('mainnet')
+    },
+    rinkeby: {
+      network_id: 4,
+      provider: providerForNetwork('rinkeby')
+    }
+  }
+}