@tetherto/mdk-core 0.0.0 → 0.12.1

package/lib/things/miner.js

@@ -0,0 +1,190 @@
+'use strict'
+
+const Thing = require('./thing')
+const { sumPoolsShares } = require('../utils')
+
+class Miner extends Thing {
+  constructor (opts = {}) {
+    super('miner', opts)
+
+    this.deviceDataCache = {}
+    this.cachedShares = { accepted: 0, rejected: 0, stale: 0 }
+  }
+
+  // Miner data fetching methods
+  async getPools () {
+    throw new Error('Not implemented')
+  }
+
+  // Miner write action validator
+  validateWriteAction (...params) {
+    const [action, ...args] = params
+
+    if (action === 'setLED') {
+      const [enabled] = args
+      if (typeof enabled !== 'boolean') {
+        throw new Error('ERR_SET_LED_ENABLED_INVALID')
+      }
+    }
+
+    return 1
+  }
+
+  checkSamePools (newPools, oldPools) {
+    if (newPools.length !== oldPools.length) {
+      return false
+    }
+
+    for (const pool of newPools) {
+      const oldPool = oldPools.find(p => p.url === pool.url)
+
+      if (oldPool === undefined) {
+        return false
+      }
+
+      if (pool.worker_name !== oldPool.username) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  // Miner control methods
+  preProcessPoolData (pools, appendId = true) {
+    if (!Array.isArray(pools)) throw new Error('ERR_INVALID_ARG_TYPE')
+
+    if (appendId) {
+      pools = pools.map((pool) => ({
+        ...pool,
+        worker_name: `${pool.worker_name}.${this.opts.id}`
+      }))
+    }
+
+    if (pools.length < 3) {
+      for (let i = pools.length; i < 3; i++) {
+        pools.push({
+          url: '',
+          worker_name: '',
+          worker_password: ''
+        })
+      }
+    }
+
+    return pools
+  }
+
+  _prepPools (pools, appendId, oldPools) {
+    pools = this.preProcessPoolData(pools, appendId)
+
+    if (oldPools) {
+      if (this.checkSamePools(pools, oldPools)) {
+        return false
+      }
+    }
+
+    return pools
+  }
+
+  async setupPools () {
+    try {
+      await this.setPools(this.conf.pools, true)
+      return { success: true }
+    } catch (e) {
+      return { success: false, error_msg: e.message }
+    }
+  }
+
+  async powerOn () {
+    throw new Error('Not implemented')
+  }
+
+  async powerOff () {
+    throw new Error('Not implemented')
+  }
+
+  async reboot () {
+    throw new Error('Not implemented')
+  }
+
+  async setPools (pools) {
+    throw new Error('Not implemented')
+  }
+
+  async setFanSpeed (speed) {
+    throw new Error('Not implemented')
+  }
+
+  async setPowerMode (mode) {
+    throw new Error('Not implemented')
+  }
+
+  async updateFirmware (firmwareFile) {
+    throw new Error('Not implemented')
+  }
+
+  async fetchDeviceData (fn, cacheTime = 5000) {
+    const lastFetched = this.deviceDataCache[fn.name]?.lastFetch
+    if (!lastFetched || lastFetched < (Date.now() - cacheTime)) {
+      const data = await fn.call(this)
+      this.deviceDataCache[fn.name] = { data, lastFetch: Date.now() }
+    }
+
+    return this.deviceDataCache[fn.name].data
+  }
+
+  _getStatus (errors, stats) {
+    // no-op
+  }
+
+  _isSuspended (stats) {
+    // no-op
+  }
+
+  _calcPowerW (stats) {
+    // no-op
+  }
+
+  _calcAvgTemp (stats) {
+    // no-op
+  }
+
+  _getPowerMode (stats) {
+    // no-op
+  }
+
+  _calcEfficiency (stats, summary) {
+    // no-op
+  }
+
+  _calcHashrates (stats) {
+    // no-op
+  }
+
+  _calcNewShares (pools) {
+    // sometimes randomly device returns empty or no pools, skip such cases
+    if (!Array.isArray(pools) || !pools.length) {
+      return { accepted: 0, rejected: 0, stale: 0 }
+    }
+
+    const currentShares = {
+      accepted: sumPoolsShares(pools, 'accepted'),
+      rejected: sumPoolsShares(pools, 'rejected'),
+      stale: sumPoolsShares(pools, 'stale')
+    }
+
+    // calculate newly added shares since the last snap
+    const newShares = {
+      accepted: currentShares.accepted >= this.cachedShares.accepted ? currentShares.accepted - this.cachedShares.accepted : currentShares.accepted,
+      rejected: currentShares.rejected >= this.cachedShares.rejected ? currentShares.rejected - this.cachedShares.rejected : currentShares.rejected,
+      stale: currentShares.stale >= this.cachedShares.stale ? currentShares.stale - this.cachedShares.stale : currentShares.stale
+    }
+
+    // cache current shares
+    this.cachedShares = { ...currentShares }
+
+    return newShares
+  }
+}
+
+module.exports = Miner

package/lib/things/powermeter.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const Thing = require('./thing')
+
+class PowerMeter extends Thing {
+  constructor (opts) {
+    super('powermeter', opts)
+
+    this.cache = null
+    this.cacheTime = 0
+  }
+
+  async getRealtimeData () {
+    // snap is read at short intervals, return data from cache
+    return await this._prepSnap(true)
+  }
+
+  /**
+   * Calculate the average tension (voltage) from three phase-to-phase measurements
+   * @param {number} l1L2 - Voltage between L1 and L2
+   * @param {number} l2L3 - Voltage between L2 and L3
+   * @param {number} l3L1 - Voltage between L3 and L1
+   * @returns {number} Average tension across all three phases
+   */
+  calculateTension (l1L2, l2L3, l3L1) {
+    return (l1L2 + l2L3 + l3L1) / 3
+  }
+}
+
+module.exports = PowerMeter

package/lib/things/sensor.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const Thing = require('./thing')
+
+class Sensor extends Thing {
+  constructor (opts) {
+    super('sensor', opts)
+
+    this.cache = null
+  }
+
+  async getRealtimeData () {
+    // snap is read at short intervals, return data from cache
+    return await this._prepSnap(true)
+  }
+}
+
+module.exports = Sensor

package/lib/things/thing.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const debug = require('debug')
+const EventEmitter = require('events')
+
+class Thing extends EventEmitter {
+  constructor (type, { lastSeenTimeout = 30000, conf = {}, ...opts }) {
+    super()
+    this._lastSeen = null
+    this._errorLog = []
+    this._type = type
+    this.debug = debug(`thing:${type}`)
+    this.conf = conf
+    this.opts = {
+      lastSeenTimeout,
+      timeout: conf.timeout || 10000,
+      ...opts
+    }
+    this.lastSnap = null
+  }
+
+  debugError (data, e) {
+    this.debug(data, e)
+  }
+
+  updateLastSeen () {
+    this._lastSeen = Date.now()
+  }
+
+  isThingOnline () {
+    // if thing is offline for more than lastSeenTimeout seconds, it is considered offline
+    return this._lastSeen !== null && Date.now() - this._lastSeen < this.opts.lastSeenTimeout
+  }
+
+  validateWriteAction (...params) {
+    throw new Error('ERR_NO_IMPL')
+  }
+
+  async _prepSnap () {
+    throw new Error('ERR_NO_IMPL')
+  }
+
+  _handleErrorUpdates (errors) {
+    this._errorLog.length = 0
+    this._errorLog.push(...errors)
+  }
+
+  async getSnap () {
+    let snap
+    try {
+      const data = await this._prepSnap()
+
+      snap = {
+        success: true,
+        raw_errors: this._errorLog,
+        stats: data.stats,
+        config: data.config
+      }
+    } catch (err) {
+      this.debugError('getSnap error', err)
+      if (this.isThingOnline() && err.message !== 'ERR_OFFLINE') {
+        snap = {
+          success: false,
+          stats: {
+            status: 'error',
+            errors: [
+              {
+                msg: err.message,
+                timestamp: Date.now()
+              }
+            ]
+          }
+        }
+      } else {
+        snap = {
+          success: false,
+          stats: {
+            status: 'offline'
+          }
+        }
+      }
+    }
+
+    this.lastSnap = snap
+    return snap
+  }
+
+  async getRealtimeData () {
+    return this.lastSnap
+  }
+}
+
+module.exports = Thing