refactor: build delegate list from memory

packages/core-database-postgres/lib/connection.js

@@ -209,31 +209,14 @@ module.exports = class PostgresConnection extends ConnectionInterface {
       throw new Error('Trying to build delegates outside of round change')
     }
 
-    let data = await this.db.rounds.delegates()
-
-    // NOTE: At the launch of the blockchain we may not have enough delegates.
-    // In order to have enough forging delegates we complete the list in a
-    // deterministic way (alphabetical order of publicKey).
-    if (data.length < maxDelegates) {
-      const chosen = data.map(delegate => delegate.publicKey)
-
-      const fillerWallets = chosen.length
-        ? await this.db.rounds.placeholdersWithout(maxDelegates - data.length, chosen)
-        : await this.db.rounds.placeholders(maxDelegates - data.length)
-
-      data = data.concat(fillerWallets)
-    }
-
-    // logger.info(`got ${data.length} voted delegates`)
     const round = Math.floor((height - 1) / maxDelegates) + 1
-    data = data
-      .sort((a, b) => b.balance - a.balance)
-      .slice(0, maxDelegates)
+
+    const delegates = await this.walletManager.allActiveDelegates(maxDelegates)
       .map(delegate => ({ ...{ round }, ...delegate }))
 
-    logger.debug(`Loaded ${data.length} active delegates`)
+    logger.debug(`Loaded ${delegates.length} active delegates`)
 
-    return data
+    return delegates
   }
 
   /**

packages/core-database-postgres/lib/queries/index.js

@@ -14,9 +14,6 @@ module.exports = {
     top: loadQueryFile(__dirname, './blocks/top.sql')
   },
   rounds: {
-    delegates: loadQueryFile(__dirname, './rounds/delegates.sql'),
-    placeholders: loadQueryFile(__dirname, './rounds/placeholders.sql'),
-    placeholdersWithout: loadQueryFile(__dirname, './rounds/placeholders-without.sql'),
     delete: loadQueryFile(__dirname, './rounds/delete.sql'),
     find: loadQueryFile(__dirname, './rounds/find.sql')
   },

packages/core-database-postgres/lib/repositories/rounds.js

@@ -12,34 +12,6 @@ module.exports = class RoundsRepository extends Repository {
     return this.db.manyOrNone(sql.find, { round })
   }
 
-  /**
-   * Get all of the delegates for the current round.
-   * @return {Promise}
-   */
-  async delegates () {
-    return this.db.manyOrNone(sql.delegates)
-  }
-
-  /**
-   * Get all of the delegate placeholders for the current round.
-   * @param  {Number} limit
-   * @return {Promise}
-   */
-  async placeholders (limit) {
-    return this.db.many(sql.placeholders, { limit })
-  }
-
-  /**
-   * Get all of the delegate placeholders for the current round. This excludes
-   * already selected delegates from the initial pick & choose.
-   * @param  {Number} limit
-   * @param  {Array} publicKeys
-   * @return {Promise}
-   */
-  async placeholdersWithout (limit, publicKeys) {
-    return this.db.many(sql.placeholdersWithout, { limit, publicKeys })
-  }
-
   /**
    * Delete the round from the database.
    * @param  {Number} round

packages/core-database/lib/wallet-manager.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const Promise = require('bluebird')
+const { sumBy, orderBy } = require('lodash')
 
 const { Bignum, crypto } = require('@arkecosystem/crypto')
 const { Wallet } = require('@arkecosystem/crypto').models
-const { TRANSACTION_TYPES } = require('@arkecosystem/crypto').constants
+const { ARKTOSHI, TRANSACTION_TYPES } = require('@arkecosystem/crypto').constants
 const container = require('@arkecosystem/core-container')
 const config = container.resolvePlugin('config')
 const logger = container.resolvePlugin('logger')
@@ -349,39 +350,91 @@ module.exports = class WalletManager {
       recipient.applyTransactionToRecipient(data)
     }
 
+    this.__updateVoteBalance(sender, transaction)
+
     return transaction
   }
 
   /**
    * Remove the given transaction from a delegate.
-   * @param  {Number} type
-   * @param  {Object} data
+   * @param  {Transaction} transaction
    * @return {Transaction}
    */
-  revertTransaction ({ type, data }) {
+  revertTransaction (transaction) {
+    const { type, data } = transaction
     const sender = this.findByPublicKey(data.senderPublicKey) // Should exist
     const recipient = this.byAddress[data.recipientId]
 
     sender.revertTransactionForSender(data)
 
     // removing the wallet from the delegates index
-    if (data.type === TRANSACTION_TYPES.DELEGATE_REGISTRATION) {
+    if (type === TRANSACTION_TYPES.DELEGATE_REGISTRATION) {
       delete this.byUsername[data.asset.delegate.username]
     }
 
     if (recipient && type === TRANSACTION_TYPES.TRANSFER) {
       recipient.revertTransactionForRecipient(data)
     }
 
+    this.__updateVoteBalance(sender, transaction)
+
     return data
   }
 
+  /**
+   * Load a list of all active delegates.
+   * @param  {Number} maxDelegates
+   * @return {Array}
+   */
+  allActiveDelegates (maxDelegates) {
+    let delegates = this.allByUsername()
+
+    // NOTE: At the launch of the blockchain we may not have enough delegates.
+    // In order to have enough forging delegates we complete the list in a
+    // deterministic way (alphabetical order of publicKey).
+    if (delegates.length < maxDelegates) {
+      const publicKeys = delegates.map(delegate => delegate.publicKey)
+
+      let fillerWallets = this.allByUsername()
+
+      if (publicKeys.length) {
+        fillerWallets = fillerWallets.filter(wallet => !publicKeys.includes(wallet.publicKey))
+      }
+
+      fillerWallets = orderBy(fillerWallets, ['publicKey'], ['asc'])
+
+      delegates = delegates.concat(fillerWallets.slice(0, maxDelegates - delegates.length))
+    }
+
+    return delegates.sort((a, b) => {
+      const aBalance = +a.voteBalance.toFixed()
+      const bBalance = +b.voteBalance.toFixed()
+
+      // FIXME: The issues with block 178 and 441 are resolved on devnet but
+      // now other blocks cause issues where delegates have the same balance and
+      // sorting the public keys alphabetically doesn't solve the issue.
+
+      if (aBalance === bBalance) {
+        logger.warn(`Delegate ${a.username} (${a.publicKey}) and ${b.username} (${b.publicKey}) have a matching vote balance of ${a.voteBalance.dividedBy(ARKTOSHI).toLocaleString()}.`)
+
+        // if (a.publicKey === b.publicKey) {
+        //   throw new Error(`The balance and public key of both delegates are identical! Delegate "${a.username}" appears twice in the list.`)
+        // }
+
+        // return a.publicKey.localeCompare(b.publicKey, 'en-US-u-kf-lower')
+      }
+
+      return aBalance - bBalance
+    }).slice(0, maxDelegates)
+  }
+
   /**
    * Checks if a given publicKey is a registered delegate
    * @param {String} publicKey
    */
   __isDelegate (publicKey) {
     const delegateWallet = this.byPublicKey[publicKey]
+
     if (delegateWallet && delegateWallet.username) {
       return !!this.byUsername[delegateWallet.username]
     }
@@ -398,4 +451,25 @@ module.exports = class WalletManager {
     return wallet.balance.isZero() && !wallet.secondPublicKey && !wallet.multisignature && !wallet.username
   }
 
+  /**
+   * Update the vote balance of the delegate the vote is for.
+   * @param  {Object} sender
+   * @param  {Transaction} transaction
+   * @return {void}
+   */
+  __updateVoteBalance (sender, transaction) {
+    if (sender.vote && transaction.type === TRANSACTION_TYPES.TRANSFER) {
+      const delegate = this.findByPublicKey(sender.vote)
+      const voters = this.allByPublicKey().filter(wallet => (wallet.vote === sender.vote))
+
+      delegate.voteBalance = new Bignum(sumBy(voters, 'balance'))
+    }
+
+    if (transaction.type === TRANSACTION_TYPES.VOTE) {
+      const vote = transaction.asset.votes[0]
+      const delegate = this.findByPublicKey(vote.substr(1))
+
+      delegate.voteBalance[vote.startsWith('+') ? 'plus' : 'minus'](sender.balance)
+    }
+  }
 }

packages/crypto/lib/utils/sort-transactions.js

@@ -6,7 +6,7 @@
 module.exports = (transactions) => {
   // Map to create a new array (sort is done in place)
   // TODO does it matter modifying the order of the original array
-  return transactions.map(t => t).sort((a, b) => {
+  return transactions.sort((a, b) => {
     if (a.type < b.type) {
       return -1
     }