refactor: build delegate list from memory

packages/core-api/__tests__/__support__/utils/generate-round.js

@@ -4,6 +4,6 @@ module.exports = (delegates, round) => {
   return delegates.map(delegate => ({
     round,
     publicKey: delegate,
-    balance: bignumify('245098000000000')
+    voteBalance: bignumify('245098000000000')
   }))
 }

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

@@ -174,8 +174,6 @@ module.exports = class PostgresConnection extends ConnectionInterface {
     let currentSeed = crypto.createHash('sha256').update(seedSource, 'utf8').digest()
 
     for (let i = 0, delCount = data.length; i < delCount; i++) {
-      data[i].round = +round
-
       for (let x = 0; x < 4 && i < delCount; i++, x++) {
         const newIndex = currentSeed[x] % delCount
         const b = data[newIndex]
@@ -185,7 +183,10 @@ module.exports = class PostgresConnection extends ConnectionInterface {
       currentSeed = crypto.createHash('sha256').update(currentSeed).digest()
     }
 
-    this.activeDelegates = data
+    this.activeDelegates = data.map(delegate => {
+      delegate.round = +round
+      return delegate
+    })
 
     return this.activeDelegates
   }
@@ -210,44 +211,6 @@ module.exports = class PostgresConnection extends ConnectionInterface {
     return this.db.rounds.delete(round)
   }
 
-  /**
-   * Load a list of delegates into memory.
-   * @param  {Number} maxDelegates
-   * @param  {Number} height
-   * @return {Array}
-   */
-  async buildDelegates (maxDelegates, height) {
-    if (height > 1 && height % maxDelegates !== 1) {
-      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)
-      .map(delegate => ({ ...{ round }, ...delegate }))
-
-    logger.debug(`Loaded ${data.length} active delegates`)
-
-    return data
-  }
-
   /**
    * Load a list of wallets into memory.
    * @param  {Number} height

packages/core-database-postgres/lib/models/round.js

@@ -20,6 +20,7 @@ module.exports = class Round extends Model {
       prop: 'publicKey'
     }, {
       name: 'balance',
+      prop: 'voteBalance',
       init: col => {
         return +bignumify(col.value).toFixed()
       }

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/__tests__/interface.test.js

@@ -67,16 +67,6 @@ describe('Connection Interface', () => {
     })
   })
 
-  describe('buildDelegates', () => {
-    it('should be a function', () => {
-      expect(connectionInterface.buildDelegates).toBeFunction()
-    })
-
-    it('should throw an exception', async () => {
-      await expect(connectionInterface.buildDelegates()).rejects.toThrowError('Method [buildDelegates] not implemented!')
-    })
-  })
-
   describe('buildWallets', () => {
     it('should be a function', () => {
       expect(connectionInterface.buildWallets).toBeFunction()

packages/core-database/lib/interface.js

@@ -73,17 +73,6 @@ module.exports = class ConnectionInterface {
     throw new Error('Method [getActiveDelegates] not implemented!')
   }
 
-  /**
-   * Load a list of delegates into memory.
-   * @param  {Number} maxDelegates
-   * @param  {Number} height
-   * @return {void}
-   * @throws Error
-   */
-  async buildDelegates (maxDelegates, height) {
-    throw new Error('Method [buildDelegates] not implemented!')
-  }
-
   /**
    * Load a list of wallets into memory.
    * @param  {Number} height
@@ -291,7 +280,7 @@ module.exports = class ConnectionInterface {
           this.walletManager.updateDelegates()
           this.updateDelegateStats(height, this.activeDelegates)
           await this.saveWallets(false) // save only modified wallets during the last round
-          const delegates = await this.buildDelegates(maxDelegates, nextHeight) // active build delegate list from database state
+          const delegates = this.walletManager.activeDelegation(maxDelegates, nextHeight) // get active delegate list from in-memory wallet manager
           await this.saveRound(delegates) // save next round delegate list
           await this.getActiveDelegates(nextHeight) // generate the new active delegates list
 

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

@@ -5,6 +5,7 @@ const Promise = require('bluebird')
 const { Bignum, crypto } = require('@arkecosystem/crypto')
 const { Wallet } = require('@arkecosystem/crypto').models
 const { TRANSACTION_TYPES } = require('@arkecosystem/crypto').constants
+const { roundCalculator } = require('@arkecosystem/core-utils')
 const container = require('@arkecosystem/core-container')
 const config = container.resolvePlugin('config')
 const logger = container.resolvePlugin('logger')
@@ -184,18 +185,61 @@ module.exports = class WalletManager {
     Object.values(this.byAddress).map(wallet => (wallet.dirty = false))
   }
 
+  /**
+   * Load a list of all active delegates.
+   * @param  {Number} maxDelegates
+   * @return {Array}
+   */
+  activeDelegation (maxDelegates, height) {
+    if (height > 1 && height % maxDelegates !== 1) {
+      throw new Error('Trying to build delegates outside of round change')
+    }
+
+    const { round } = roundCalculator.calculateRound(height, maxDelegates)
+    let delegates = this.allByUsername()
+
+    if (delegates.length < maxDelegates) {
+      throw new Error(`Expected to find ${maxDelegates} delegates but only found ${delegates.length}. This indicates an issue with the genesis block & delegates.`)
+    }
+
+    delegates = delegates.sort((a, b) => {
+      const aBalance = +a.voteBalance.toFixed()
+      const bBalance = +b.voteBalance.toFixed()
+
+      if (aBalance === bBalance) {
+        // logger.warn(`Delegate ${a.username} (${a.publicKey}) and ${b.username} (${b.publicKey}) have a matching vote balance of ${a.voteBalance.dividedBy(Math.pow(10, 8)).toLocaleString()}.`)
+
+        if (a.publicKey === b.publicKey) {
+          logger.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 bBalance - aBalance
+    }).slice(0, maxDelegates)
+
+    logger.debug(`Loaded ${delegates.length} active delegates`)
+
+    return delegates.map(delegate => ({ ...{ round }, ...delegate }))
+  }
+
   /**
    * Update the vote balances of delegates.
    * @return {void}
    */
   updateDelegates () {
-    Object.values(this.byUsername).forEach(delegate => (delegate.voteBalance = Bignum.ZERO))
+    Object
+      .values(this.byUsername)
+      .forEach(delegate => (delegate.voteBalance = Bignum.ZERO))
+
     Object.values(this.byPublicKey)
       .filter(voter => !!voter.vote)
       .forEach(voter => {
         const delegate = this.byPublicKey[voter.vote]
         delegate.voteBalance = delegate.voteBalance.plus(voter.balance)
       })
+
     Object.values(this.byUsername)
       .sort((a, b) => +(b.voteBalance.minus(a.voteBalance)).toFixed())
       .forEach((delegate, index) => (delegate.rate = index + 1))
@@ -354,18 +398,18 @@ module.exports = class WalletManager {
 
   /**
    * 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]
     }
 
@@ -382,6 +426,7 @@ module.exports = class WalletManager {
    */
   __isDelegate (publicKey) {
     const delegateWallet = this.byPublicKey[publicKey]
+
     if (delegateWallet && delegateWallet.username) {
       return !!this.byUsername[delegateWallet.username]
     }
@@ -397,5 +442,4 @@ module.exports = class WalletManager {
   __canBePurged (wallet) {
     return wallet.balance.isZero() && !wallet.secondPublicKey && !wallet.multisignature && !wallet.username
   }
-
 }

packages/core-utils/lib/round-calculator.js

@@ -5,11 +5,12 @@ const container = require('@arkecosystem/core-container')
 /**
  * Calculate the round and nextRound based on the height and active delegates.
  * @param  {Number} height
+ * @param  {Number} maxDelegates
  * @return {Object}
  */
-exports.calculateRound = (height) => {
+exports.calculateRound = (height, maxDelegates = undefined) => {
   const config = container.resolvePlugin('config')
-  const maxDelegates = config.getConstants(height).activeDelegates
+  maxDelegates = maxDelegates || config.getConstants(height).activeDelegates
 
   const round = Math.floor((height - 1) / maxDelegates) + 1
   const nextRound = Math.floor((height) / maxDelegates) + 1

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
     }