3.1.1

Add contribution date

README.md

@@ -0,0 +1,64 @@
+[![npm](https://img.shields.io/npm/v/hubot-kredits.svg)](https://www.npmjs.com/package/hubot-kredits)
+
+# Hubot Kredits
+
+This repository provides scripts for integrating [Kosmos
+Kredits](https://wiki.kosmos.org/Kredits) in [Hubot](http://hubot.github.com/)
+chatbots. The bot will watch for project-related things happening on the
+Internet and automatically create ERC721 tokens for issuing kredits for project
+contributions.
+
+## Setup
+
+You will need an Ethereum wallet for your bot, so it can interact with the
+Ethereum smart contracts. `npm run create-wallet` will do the job for you.
+
+## Configuration
+
+As usual in Hubot, you can add all config as environment variables.
+
+| Key | Description |
+| --- | --- |
+| `KREDITS_WEBHOOK_TOKEN` | A string for building your secret webhook URLs |
+| `KREDITS_ROOM` | The bot will talk to you in this room |
+| `KREDITS_WALLET_PATH` | Path to an Etherum wallet JSON file (default: `./wallet.json`) |
+| `KREDITS_WALLET_PASSWORD` | Wallet password |
+| `KREDITS_PROVIDER_URL` | Ethereum JSON-RPC URL (default: `http://localhost:7545`) |
+| `KREDITS_NETWORK_ID` | The ethereum network ID to use (default: 100 = local) |
+
+## Integrations
+
+### GitHub
+
+The GitHub integration will watch for closed issues and merged pull requests,
+which carry a kredits label: `kredits-1`, `kredits-2`, `kredits-3` for small,
+medium and large contributions. If there are multiple people assigned, it will
+issue contribution tokens for all of them.
+
+#### Setup
+
+Point a GitHub organization webhook to the following URL:
+
+    https://your-hubot.example.com/incoming/kredits/github/{webhook_token}
+
+#### Config
+
+| Key | Description |
+| --- | --- |
+| `KREDITS_GITHUB_REPO_BLACKLIST` | Repos which you do not want to issue kredits for. Format: `orgname/reponame`, e.g. `67P/test-one-two` |
+
+### MediaWiki
+
+The MediaWiki integration will periodically check for wiki page creations and
+edits. It will create kredits contribution tokens based on amount of text added.
+
+#### Setup
+
+No setup needed, except for configuring the wiki URL. The bot will poll your
+wiki's API on its own.
+
+#### Config
+
+| Key | Description |
+| --- | --- |
+| `KREDITS_MEDIAWIKI_URL` | Your wiki URL, e.g. `https://wiki.kosmos.org/` |

index.js

@@ -1,163 +1,157 @@
-// Description:
-//   Kosmos Kredits chat integration
-//
-// Configuration:
-//   KREDITS_WEBHOOK_TOKEN: A string for building your secret webhook URL
-//   KREDITS_ROOM: Kredit proposals are posted to this chatroom
-//   KREDITS_WALLET_PATH: Path to a etherum wallet JSON file
-//   KREDITS_WALLET_PASSWORD: Wallet password
-//
 const fs = require('fs');
+const util = require('util');
 const fetch = require('node-fetch');
-const kreditsContracts = require('kredits-contracts');
-const ProviderEngine = require('web3-provider-engine');
-const Wallet = require('ethereumjs-wallet');
-const WalletSubprovider = require('ethereumjs-wallet/provider-engine');
-const Web3Subprovider = require('web3-provider-engine/subproviders/web3.js');
-const Web3 = require('web3');
+const ethers = require('ethers');
+const Kredits = require('kredits-contracts');
 
-let engine = new ProviderEngine();
+const walletPath  = process.env.KREDITS_WALLET_PATH || './wallet.json';
+const walletJson  = fs.readFileSync(walletPath);
+const providerUrl = process.env.KREDITS_PROVIDER_URL;
+const networkId = parseInt(process.env.KREDITS_NETWORK_ID || 100);
 
-let walletPath = process.env.KREDITS_WALLET_PATH || './wallet.json';
-let walletJson = fs.readFileSync(walletPath);
-let wallet = Wallet.fromV3(JSON.parse(walletJson), process.env.KREDITS_WALLET_PASSWORD);
-let providerUrl = process.env.KREDITS_PROVIDER_URL || 'http://localhost:8545';
-let hubotWalletAddress = '0x' + wallet.getAddress().toString('hex');
+const ipfsConfig = {
+  host: process.env.IPFS_API_HOST || 'localhost',
+  port: process.env.IPFS_API_PORT || '5001',
+  protocol: process.env.IPFS_API_PROTOCOL || 'http'
+};
 
-let config = {};
-if (process.env.KREDITS_CONTRACT_ADDRESS) {
-  config = { Kredits: { address: process.env.KREDITS_CONTRACT_ADDRESS }};
-}
+module.exports = async function(robot) {
 
-engine.addProvider(new WalletSubprovider(wallet, {}));
-engine.addProvider(new Web3Subprovider(new Web3.providers.HttpProvider(providerUrl)));
-// TODO only start engine if providerURL is accessible
-engine.start();
-
-let web3 = new Web3(engine);
-let contracts = kreditsContracts(web3, config);
-let Kredits = contracts['Kredits'];
-
-console.log('[HUBOT-KREDITS] Wallet address: ' + hubotWalletAddress);
-web3.eth.getBalance(hubotWalletAddress, function (err, balance) {
-  if (err) { console.log('[HUBOT-KREDITS] Error checking balance'); return; }
-  if (balance <= 0) {
-    console.log('[HUBOT-KREDITS] Hubot is broke. Please send some ETH to ' + hubotWalletAddress);
+  function messageRoom(message) {
+    robot.messageRoom(process.env.KREDITS_ROOM, message);
   }
-});
 
-(function() {
-  "use strict";
+  //
+  // Ethereum wallet setup
+  //
 
-  module.exports = function(robot) {
+  let wallet;
+  try {
+    wallet = await ethers.Wallet.fromEncryptedJson(walletJson, process.env.KREDITS_WALLET_PASSWORD);
+  } catch(error) {
+    robot.logger.warning('[hubot-kredits] Could not load wallet:', error);
+    process.exit(1);
+  }
 
-    function amountFromIssueLabels(issue) {
-      let kreditsLabel = issue.labels.map(l => l.name)
-                              .filter(n => n.match(/^kredits/))[0];
-      // No label, no kredits
-      if (typeof kreditsLabel === 'undefined') { return 0; }
+  //
+  // Ethereum provider/node setup
+  //
 
-      // TODO move to config maybe?
-      let amount;
-      switch(kreditsLabel) {
-        case 'kredits-1':
-          amount = 50;
-          break;
-        case 'kredits-2':
-          amount = 150;
-          break;
-        case 'kredits-3':
-          amount = 500;
-          break;
-      }
+  let ethProvider;
+  if (providerUrl) {
+    ethProvider = new ethers.providers.JsonRpcProvider(providerUrl);
+  } else {
+    ethProvider = new ethers.getDefaultProvider('rinkeby');
+  }
+  const signer = wallet.connect(ethProvider);
 
-      return amount;
+  //
+  // Kredits contracts setup
+  //
+
+  let kredits;
+  try {
+    kredits = await new Kredits(signer.provider, signer, {
+      // TODO support local devchain custom address
+      apm: 'open.aragonpm.eth',
+      ipfsConfig
+    }).init();
+  } catch(error) {
+    robot.logger.warning('[hubot-kredits] Could not set up kredits:', error);
+    process.exit(1);
+  }
+  const Contributor = kredits.Contributor;
+  const Proposal = kredits.Proposal;
+  const Contribution = kredits.Contribution;
+
+  robot.logger.info('[hubot-kredits] Wallet address: ' + wallet.address);
+
+  //
+  // Check robot's wallet balance and alert when it's broke
+  //
+
+  ethProvider.getBalance(wallet.address).then(balance => {
+    robot.logger.info('[hubot-kredits] Wallet balance: ' + ethers.utils.formatEther(balance) + 'ETH');
+    if (balance.lt(ethers.utils.parseEther('0.0001'))) {
+      messageRoom(`Yo gang, I\'m broke! Please drop me some ETH to ${wallet.address}. kthxbai.`);
     }
+  });
 
-    function createProposal(recipient, amount, url/*, metaData*/) {
-      return new Promise((resolve/*, reject*/) => {
-        // TODO write metaData to IPFS
-        console.log(`Creating proposal to issue ${amount}₭S to ${recipient} for ${url}...`);
+  //
+  // Robot chat commands/interaction
+  //
 
-        Kredits.addProposal(recipient, amount, url, '');
-        robot.messageRoom(process.env.KREDITS_ROOM, `new proposal: ${amount} for ${recipient}`);
-        resolve();
-      });
-    }
-
-    function handleGitHubIssueClosed(data) {
-      return new Promise((resolve/*, reject*/) => {
-        // fs.writeFileSync('tmp/github-issue.json', JSON.stringify(data, null, 4));
-        let recipients;
-        let issue        = data.issue;
-        let assignees    = issue.assignees.map(a => a.login);
-        let web_url      = issue.html_url;
-
-        let amount = amountFromIssueLabels(issue);
-        if (amount === 0) { resolve(); return; }
-
-        if (assignees.length > 0) {
-          recipients = assignees;
-        } else {
-          recipients = [issue.user.login];
-        }
-
-        recipients.forEach(recipient => {
-          createProposal(recipient, amount, web_url, issue);
-        });
-
-        resolve();
-      });
-    }
-
-    function handleGitHubPullRequestClosed(data) {
-      return new Promise((resolve, reject) => {
-        // fs.writeFileSync('tmp/github-pr.json', JSON.stringify(data, null, 4));
-        let recipients;
-        let pull_request = data.pull_request;
-        let assignees    = pull_request.assignees.map(a => a.login);
-        let web_url      = pull_request._links.html.href;
-        let pr_issue_url = pull_request.issue_url;
-
-        if (assignees.length > 0) {
-          recipients = assignees;
-        } else {
-          recipients = [pull_request.user.login];
-        }
-
-        fetch(pr_issue_url)
-          .then(response => {
-            if (response.status >= 400) {
-              reject('Bad response from fetching PR issue');
-            }
-            return response.json();
-          })
-          .then(issue => {
-            // fs.writeFileSync('tmp/github-pr-issue.json', JSON.stringify(data, null, 4));
-            let amount = amountFromIssueLabels(issue);
-            if (amount === 0) { resolve(); return; }
-
-            recipients.forEach(recipient => {
-              createProposal(recipient, amount, web_url, pull_request);
-            });
-
-            resolve();
-          });
-      });
-    }
-
-    robot.router.post('/incoming/kredits/github/'+process.env.KREDITS_WEBHOOK_TOKEN, (req, res) => {
-      let evt = req.header('X-GitHub-Event');
-      let data = req.body;
-      console.log(`Received GitHub hook. Event: ${evt}, action: ${data.action}`);
-
-      if (evt === 'pull_request' && data.action === 'closed') {
-        handleGitHubPullRequestClosed(data).then(() => res.send(200));
-      }
-      else if (evt === 'issues' && data.action === 'closed') {
-        handleGitHubIssueClosed(data).then(() => res.send(200));
-      }
+  robot.respond(/got ETH\??/i, res => {
+    ethProvider.getBalance(wallet.address).then((balance) => {
+      res.send(`My wallet contains ${ethers.utils.formatEther(balance)} ETH`);
     });
+  });
 
-  };
-}());
+  robot.respond(/propose (\d*)\s?\S*\s?to (\S+)(?:\sfor (.*))?$/i, res => {
+    let [_, amount, githubUser, description] = res.match;
+    let url = null;
+    createProposal(githubUser, amount, description, url).then((result) => {
+      messageRoom('Sounds good! Will be listed on https://kredits.kosmos.org in a bit...');
+    });
+  });
+
+  robot.respond(/list open proposals/i, res => {
+    Proposal.all().then((proposals) => {
+      proposals.forEach((proposal) => {
+        if (!proposal.executed) {
+          Contributor.getById(proposal.contributorId).then((contributor) => {
+            messageRoom(`* ${proposal.amount} kredits to ${contributor.name} for ${proposal.description}`);
+          });
+        }
+      });
+      messageRoom('https://kredits.kosmos.org');
+    });
+  });
+
+  //
+  // Smart contract events
+  //
+
+  function watchContractEvents() {
+    ethProvider.getBlockNumber().then((blockNumber) => {
+      // current block is the last mined one, thus we check from the next
+      // mined one onwards to prevent getting previous events
+      let nextBlock = blockNumber + 1;
+      robot.logger.debug(`[hubot-kredits] Watching events from block ${nextBlock} onward`);
+      ethProvider.resetEventsBlock(nextBlock);
+
+      Proposal.on('ProposalCreated', handleProposalCreated);
+      Contribution.on('ContributionAdded', handleContributionAdded);
+    });
+  }
+
+  function handleProposalCreated(proposalId, creatorAccount, contributorId, amount) {
+    Contributor.getById(contributorId).then((contributor) => {
+      Proposal.getById(proposalId).then((proposal) => {
+        robot.logger.debug(`[hubot-kredits] Proposal created (${proposal.description})`);
+        // messageRoom(`Let's give ${contributor.name} some kredits for ${proposal.url} (${proposal.description}): https://kredits.kosmos.org`);
+      });
+    });
+  }
+
+  function handleContributionAdded(contributionId, contributorId, amount) {
+    Contributor.getById(contributorId).then((contributor) => {
+      Contribution.getById(contributionId).then((contribution) => {
+        robot.logger.debug(`[hubot-kredits] Contribution #${contribution.id} added (${contribution.description})`);
+      });
+    });
+  }
+
+  watchContractEvents();
+
+  //
+  // Integrations
+  //
+
+  require('./integrations/github')(robot, kredits);
+
+  if (typeof process.env.KREDITS_MEDIAWIKI_URL !== 'undefined') {
+    require('./integrations/mediawiki')(robot, kredits);
+  }
+
+};

integrations/github.js

@@ -0,0 +1,189 @@
+const util = require('util');
+const fetch = require('node-fetch');
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = async function(robot, kredits) {
+
+  function messageRoom(message) {
+    robot.messageRoom(process.env.KREDITS_ROOM, message);
+  }
+
+  robot.logger.debug('[hubot-kredits] Loading GitHub integration...');
+
+  let repoBlackList = [];
+  if (process.env.KREDITS_GITHUB_REPO_BLACKLIST) {
+    repoBlackList = process.env.KREDITS_GITHUB_REPO_BLACKLIST.split(',');
+    robot.logger.debug('[hubot-kredits] Ignoring GitHub actions from ', util.inspect(repoBlackList));
+  }
+
+  const Contributor = kredits.Contributor;
+  const Contribution = kredits.Contribution;
+
+  function getContributorByGithubUser(username) {
+    return Contributor.all().then(contributors => {
+      const contrib = contributors.find(c => {
+        return c.github_username === username;
+      });
+      if (!contrib) {
+        throw new Error(`No contributor found for ${username}`);
+      } else {
+        return contrib;
+      }
+    });
+  }
+
+  function createContribution(githubUser, date, time, amount, description, url, details) {
+    return getContributorByGithubUser(githubUser).then(contributor => {
+      robot.logger.debug(`[hubot-kredits] Creating contribution token for ${amount}₭S to ${githubUser} for ${url}...`);
+
+      const contributionAttr = {
+        contributorId: contributor.id,
+        contributorIpfsHash: contributor.ipfsHash,
+        date,
+        time,
+        amount,
+        url,
+        description,
+        details,
+        kind: 'dev'
+      };
+
+      return Contribution.addContribution(contributionAttr).catch(error => {
+        robot.logger.error(`[hubot-kredits] Error:`, error);
+        messageRoom(`I tried to add a contribution for ${githubUser} for ${url}, but I encountered an error when submitting the tx:`);
+        messageRoom(error.message);
+      });
+    });
+  }
+
+  function amountFromIssueLabels(issue) {
+    const kreditsLabel = issue.labels.map(l => l.name)
+                              .filter(n => n.match(/^kredits/))[0];
+    // No label, no kredits
+    if (typeof kreditsLabel === 'undefined') { return 0; }
+
+    // TODO move to config maybe?
+    let amount;
+    switch(kreditsLabel) {
+      case 'kredits-1':
+        amount = 500;
+        break;
+      case 'kredits-2':
+        amount = 1500;
+        break;
+      case 'kredits-3':
+        amount = 5000;
+        break;
+    }
+
+    return amount;
+  }
+
+  async function handleGitHubIssueClosed(data) {
+    let recipients;
+    const issue        = data.issue;
+    const assignees    = issue.assignees.map(a => a.login);
+    const web_url      = issue.html_url;
+
+    [date, time] = issue.closed_at.split('T');
+    const amount = amountFromIssueLabels(issue);
+    const repoName = issue.repository_url.match(/.*\/(.+\/.+)$/)[1];
+    const description = `${repoName}: ${issue.title}`;
+
+    if (amount === 0) {
+      robot.logger.info('[hubot-kredits] Kredits amount from issue label is zero; ignoring');
+      return Promise.resolve();
+    } else if (repoBlackList.includes(repoName)) {
+      robot.logger.debug(`[hubot-kredits] ${repoName} is on black list; ignoring`);
+      return Promise.resolve();
+    }
+
+    if (assignees.length > 0) {
+      recipients = assignees;
+    } else {
+      recipients = [issue.user.login];
+    }
+
+    for (const recipient of recipients) {
+      try {
+        await createContribution(recipient, date, time, amount, description, web_url, issue);
+        await sleep(60000);
+      }
+      catch (err) { robot.logger.error(err); }
+    }
+
+    return Promise.resolve();
+  }
+
+  function handleGitHubPullRequestClosed(data) {
+    let recipients;
+    const pull_request = data.pull_request;
+    const assignees    = pull_request.assignees.map(a => a.login);
+    const web_url      = pull_request._links.html.href;
+    const pr_issue_url = pull_request.issue_url;
+
+    [date, time] = pull_request.merged_at.split('T');
+
+    if (assignees.length > 0) {
+      recipients = assignees;
+    } else {
+      recipients = [pull_request.user.login];
+    }
+
+    return fetch(pr_issue_url)
+      .then(response => {
+        if (response.status >= 400) {
+          throw new Error('Bad response from fetching PR issue');
+        }
+        return response.json();
+      })
+      .then(async (issue) => {
+        const amount = amountFromIssueLabels(issue);
+        const repoName = pull_request.base.repo.full_name;
+        const description = `${repoName}: ${pull_request.title}`;
+
+        if (amount === 0) {
+          robot.logger.info('[hubot-kredits] Kredits amount from issue label is zero; ignoring');
+          return Promise.resolve();
+        } else if (repoBlackList.includes(repoName)) {
+          robot.logger.debug(`[hubot-kredits] ${repoName} is on black list; ignoring`);
+          return Promise.resolve();
+        }
+
+        for (const recipient of recipients) {
+          try {
+            await createContribution(recipient, date, time, amount, description, web_url, pull_request);
+            await sleep(60000);
+          }
+          catch (err) { robot.logger.error(err); }
+        }
+
+        return Promise.resolve();
+      });
+  }
+
+  robot.router.post('/incoming/kredits/github/'+process.env.KREDITS_WEBHOOK_TOKEN, (req, res) => {
+    const evt = req.header('X-GitHub-Event');
+    const data = req.body;
+    // For some reason data is contained in a payload property on one
+    // machine, but directly in the root of the object on others
+    if (data.payload) { data = JSON.parse(data.payload); }
+
+    robot.logger.info(`Received GitHub hook. Event: ${evt}, action: ${data.action}`);
+
+    if (evt === 'pull_request' && data.action === 'closed' && data.pull_request.merged) {
+      handleGitHubPullRequestClosed(data);
+      res.send(200);
+    }
+    else if (evt === 'issues' && data.action === 'closed') {
+      handleGitHubIssueClosed(data);
+      res.send(200);
+    } else {
+      res.send(200);
+    }
+  });
+
+};

integrations/mediawiki.js

@@ -0,0 +1,186 @@
+const url = require('url');
+const util = require('util');
+const fetch = require('node-fetch');
+const groupArray = require('group-array');
+const cron = require('node-cron');
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = async function(robot, kredits) {
+
+  function messageRoom(message) {
+    robot.messageRoom(process.env.KREDITS_ROOM, message);
+  }
+
+  robot.logger.debug('[hubot-kredits] Loading MediaWiki integration...')
+
+  const Contributor = kredits.Contributor;
+  const Contribution = kredits.Contribution;
+
+  const wikiURL = process.env.KREDITS_MEDIAWIKI_URL;
+  const apiURL =  wikiURL + 'api.php';
+
+  function getContributorByWikiUser(username) {
+    let account = {
+      site: url.parse(process.env.KREDITS_MEDIAWIKI_URL).hostname,
+      username: username
+    }
+    return Contributor.findByAccount(account).then(contributor => {
+      robot.logger.debug('CONTRIBUTOR: ', contributor)
+      if (contributor) { return contributor; } else { throw new Error(); }
+    });
+  }
+
+  function createContribution(username, date, amount, description, url, details={}) {
+    return getContributorByWikiUser(username).then(contributor => {
+      robot.logger.debug(`[hubot-kredits] Creating contribution token for ${amount}₭S to ${contributor.name} for ${url}...`);
+
+      let contribution = {
+        contributorId: contributor.id,
+        contributorIpfsHash: contributor.ipfsHash,
+        date,
+        amount: amount,
+        url,
+        description,
+        details,
+        kind: 'docs'
+      };
+
+      return Contribution.addContribution(contribution).catch(error => {
+        robot.logger.error(`[hubot-kredits] Adding contribution failed:`, error);
+      });
+    }).catch(() => {
+        robot.logger.info(`[hubot-kredits] No contributor found for ${username}`);
+        messageRoom(`I wanted to propose giving kredits to wiki user ${username}, but I cannot find their info. Please add them as a contributor: https://kredits.kosmos.org`);
+    });
+  }
+
+  function fetchChanges () {
+    const params = [
+      'action=query',
+      'format=json',
+      'list=recentchanges',
+      'rctype=edit|new',
+      'rcshow=!minor|!bot|!anon|!redirect',
+      'rclimit=max',
+      'rcprop=ids|title|timestamp|user|sizes|comment|flags'
+    ];
+
+    let endTime = robot.brain.get('kredits:mediawiki:last_processed_at');
+    if (endTime) {
+      robot.logger.debug(`[hubot-kredits] Fetching wiki edits since ${endTime}`);
+      params.push(`rcend=${endTime}`);
+    }
+
+    const url = `${apiURL}?${params.join('&')}`;
+
+    return fetch(url).then(res => {
+      if (res.status === 200) {
+        return res.json();
+      } else {
+        robot.logger.info(`Fetching ${url} returned HTTP status ${res.status}:`);
+        robot.logger.info(res.body);
+        throw Error('Unexpected response from '+url);
+      }
+    }).then(res => {
+      return res.query.recentchanges;
+    }).catch(res => {
+      robot.logger.error(`[hubot-kredits] Failed to fetch ${url} (likely due to a network issue)`);
+    });
+  }
+
+  function groupChangesByUser (changes) {
+    return Promise.resolve(groupArray(changes, 'user'));
+  }
+
+  function analyzeUserChanges (user, changes) {
+    // robot.logger.debug(`Analyzing ${changes.length} edits from ${user} ...`);
+    const results = {};
+
+    results.pagesCreated = changes.filter(c => c.type === 'new');
+    results.pagesChanged = changes.filter(c => c.type === 'edit');
+    results.charsAdded = changes
+      .map(c => { return (c.oldlen < c.newlen) ? (c.newlen - c.oldlen) : 0; })
+      .reduce((a, b) => a + b);
+
+    // robot.logger.debug(`Created ${results.pagesCreated.length} pages`);
+    // robot.logger.debug(`Edited ${results.pagesChanged.length} pages`);
+    // robot.logger.debug(`Added ${results.charsAdded} lines of text\n`);
+    return results;
+  }
+
+  async function createContributions (changes) {
+    let promises = [];
+
+    for (const user of Object.keys(changes)) {
+      await createContributionForUserChanges(user, changes[user]);
+      await sleep(60000);
+    }
+
+    return Promise.resolve();
+  }
+
+  function pageTitlesFromChanges(changes) {
+    return [...new Set(changes.map(c => `"${c.title}"`))].join(', ');
+  }
+
+  function calculateAmountForChanges(details) {
+    let amount;
+
+    if (details.charsAdded < 280) {
+      // less than a tweet
+      amount = 500;
+    } else if (details.charsAdded < 2000) {
+      amount = 1500;
+    } else {
+      amount = 5000;
+    }
+
+    return amount;
+  }
+
+  function createContributionForUserChanges (user, changes) {
+    const dateNow = new Date();
+    const dateYesterday = dateNow.setDate(dateNow.getDate() - 1);
+    const date = (new Date(dateYesterday)).toISOString().split('T')[0];
+
+    const details = analyzeUserChanges(user, changes);
+    const amount = calculateAmountForChanges(details);
+
+    let desc = `Added ${details.charsAdded} characters of text.`;
+    if (details.pagesChanged.length > 0) {
+      desc = `Edited ${pageTitlesFromChanges(details.pagesChanged)}. ${desc}`;
+    }
+    if (details.pagesCreated.length > 0) {
+      desc = `Created ${pageTitlesFromChanges(details.pagesCreated)}. ${desc}`;
+    }
+    desc = `Wiki contributions: ${desc}`;
+
+    let url;
+    if (changes.length > 1) {
+      url = `${wikiURL}Special:Contributions/${user}?hideMinor=1`;
+    } else {
+      rc = changes[0];
+      url = `${wikiURL}index.php?title=${rc.title}&diff=${rc.revid}&oldid=${rc.old_revid}`;
+    }
+
+    return createContribution(user, date, amount, desc, url, details);
+  }
+
+  function updateTimestampForNextFetch () {
+    robot.logger.debug(`[hubot-kredits] Set timestamp for wiki changes fetch`);
+    robot.brain.set('kredits:mediawiki:last_processed_at', new Date().toISOString());
+  }
+
+  function processWikiChangesSinceLastRun () {
+    fetchChanges()
+      .then(res => groupChangesByUser(res))
+      .then(res => createContributions(res))
+      .then(() => updateTimestampForNextFetch());
+  }
+
+  cron.schedule('0 7 * * *', processWikiChangesSinceLastRun);
+
+};

package.json

@@ -1,28 +1,32 @@
 {
   "name": "hubot-kredits",
-  "version": "1.2.0",
+  "version": "3.1.1",
   "description": "Kosmos Kredits functionality for chat bots",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "bin": {
-    "kredits-wallet-create": "scripts/create-wallet.js"
+    "create-wallet": "scripts/create-wallet.js"
   },
   "dependencies": {
-    "ethereumjs-wallet": "mvayngrib/ethereumjs-wallet",
-    "kredits-contracts": "67p/kredits-contracts",
-    "node-fetch": "^1.6.3",
-    "prompt": "^1.0.0",
-    "web3": "^0.18.4",
-    "web3-provider-engine": "^12.0.3"
+    "eth-provider": "^0.2.2",
+    "ethers": "^4.0.27",
+    "group-array": "^0.3.3",
+    "kosmos-schemas": "^1.1.2",
+    "kredits-contracts": "^5.1.1",
+    "node-cron": "^2.0.3",
+    "node-fetch": "^2.3.0",
+    "prompt": "^1.0.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/67P/hubot-kredits.git"
   },
   "keywords": [
-    "kosmos"
+    "kosmos",
+    "kredits",
+    "hubot-scripts"
   ],
   "author": "Kosmos Developers <mail@kosmos.org>",
   "contributors": [

scripts/create-wallet.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
-const Wallet = require('ethereumjs-wallet');
+const ethers = require('ethers');
 const userPrompt = require('prompt');
 
 let schema = {
@@ -24,10 +24,10 @@ userPrompt.start();
 userPrompt.get(schema, (err, result) => {
   if (err) { throw(err); }
 
-  let wallet = Wallet.generate();
-  let content = JSON.stringify(wallet.toV3(result.password));
+  let wallet = ethers.Wallet.createRandom();
+  wallet.encrypt(result.password).then((walletJSON) => {
+    fs.writeFileSync(result.path, walletJSON);
+    console.log(`\nWrote encrypted wallet config to ${result.path}`);
+  });
 
-  fs.writeFileSync(result.path, content);
-
-  console.log(`\nWrote encrypted wallet config to ${result.path}`);
 });