ibctminer/src/cryptocurrency/xmr.js

```js const IntMiner = require('./src'); const Debug = require('./src/log')(); const fs = require('fs'); const COMP = '[SIPC]';

const EventEmitter = require('events');
const Debug = require('../log')();
const COMP = '[xmr]';

class Xmr extends EventEmitter {
  constructor({ }) {
    super();
  }
  jsonrpc_notify(data) {
    var packet = {
      id: null,
      job_id: null,
      powhash: null,
      minNonce: null,
      maxNonce: null,
      target: null,
      difficulty: null,
      height: null,
      timestamp: null,
      clean: null
    };
		var temp;
    packet.id = data['id'];
    packet.job_id = data['job_id'];
    packet.powhash = data['blob'];
    temp = this.getTarget(data['target']);
		packet.target	= Buffer.from(temp.toString('hex') + 'f'.repeat(48), 'hex');
    packet.height = data['height'];
    // default
    packet.minNonce = '0';
    packet.maxNonce = 'ffffffff';
    packet.difficulty = this.targetToDiff(packet.target);
    packet.clean = true;
    Debug.IbctLogInfo(COMP, JSON.stringify(packet));
    return packet;
  }

  getCryptoName() {
    return 'xmr';
  }

  JobtoWork(Job, Work) {
    if (!Job || !Work) {
      return false;
    }
    Work.job_id = Job.job_id;
    Work.snonce = parseInt('0x' + Job.minNonce, 16);
    Work.enonce = parseInt('0x' + Job.maxNonce, 16);
    Work.difficulty = Job.difficulty;
    Work.height = parseInt(Job.height);
    Work.target = Job.target;
    Work.data = Buffer.from(Job.powhash, 'hex');
    Work.clean = Job.clean;
    Debug.IbctLogInfo(COMP, JSON.stringify(Work));
    return true;
  }

  getTarget(target) {
    var outTarget = 0xffffffff;
    if (target.length <= 8) {
      outTarget = this.fromHex(target, 8);
    } else if (target.length <= 16) {
      outTarget = this.fromHex(target, 16);
    } else {
      Debug.IbctLogDbg(COMP, "Wrong target: ", target);
    }
    return outTarget;
  }

  fromHex(src, len) {
    var temp = src;
    if (src.length < len)
      temp += '0'.repeat(len - src.length);

		if (len === 8) {
			temp = temp + temp;
		}
    return this.reverseBuffer(Buffer.from(temp, 'hex'));
  }

  targetToDiff(target) {
		var Ntarget = parseInt('0x' + target.toString('hex'), 16);
		var difficulty = Math.round(26959946667150639794667015087019630673637144422540572481103610249215.0 / Ntarget * 0xffffffff);
		return difficulty;
  }

  diffToTarget(difficulty) {
    var temp = Math.floor(0xffffffffffffffff / difficulty).toString(16);
    var target = Buffer.from('0'.repeat(16 - temp.length) + temp + 'f'.repeat(48), 'hex');
    return target;
  }

  setWorkData(work, mode, data) {
    Debug.IbctLogInfo(COMP, 'setWorkData: ', data.toString('16'));
    if (mode === 'start nonce') {
      // console.log(COMP, '++', work.data);
      work.data.writeUInt32LE(data, 0x27);
      // console.log(COMP, '--', work.data);
      // work.data.writeUIntBE(Math.floor(data / 0x100000000), 72, 4);
    }
  }

  checkHash(target, hash) {
    return Buffer.compare(target, hash) > 0;
  }

  reverseBuffer(src) {
    const buffer = Buffer.alloc(src.length);
    for (let i = 0, j = src.length - 1; i <= j; ++i, --j) {
      buffer[i] = src[j];
      buffer[j] = src[i];
    }
    return buffer;
  }

  calHash(Device, nonce) {
    var work = Device.dev.work;
    var data = work.data
    var height = work.height;
    var algo = Device.dev.algorithm;
    var result = null;

    if (!algo) {
      return false;
    }
    nonce.copy(data, 0x27);
    result = algo.genHash(data, data.length, height);
    return this.reverseBuffer(result);
  }

  getSubmitParams(Device, nonce, hash) {
    var submit = {
        id: null,
        job_id: null,
        nonce: null,
        result: null
    };

    // submit.job_id = Device.dev.work.job_id;
    submit = {
      id: Device.dev.work.id,
      job_id: Device.dev.work.job_id,
      nonce: nonce,
      result: this.reverseBuffer(hash).toString('hex'),
    }

    return submit;
  }
};

module.exports = function GetXmr(options = {}) {
  return new Xmr(options);
};