287 lines
9.4 KiB
JavaScript
287 lines
9.4 KiB
JavaScript
const bignum = require('bignum');
|
|
const base58 = require('base58-native');
|
|
const bitcoin = require('bitcoinjs-lib');
|
|
|
|
const diff1 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
|
|
|
|
function reverseBuffer(buff) {
|
|
let reversed = Buffer.alloc(buff.length);
|
|
for (let i = buff.length - 1; i >= 0; i--) reversed[buff.length - i - 1] = buff[i];
|
|
return reversed;
|
|
}
|
|
|
|
function reverseByteOrder(buff) {
|
|
for (let i = 0; i < 8; i++) buff.writeUInt32LE(buff.readUInt32BE(i * 4), i * 4);
|
|
return reverseBuffer(buff);
|
|
}
|
|
|
|
function packInt32LE(num) {
|
|
let buff = Buffer.alloc(4);
|
|
buff.writeInt32LE(num, 0);
|
|
return buff;
|
|
}
|
|
|
|
function packInt32BE(num) {
|
|
let buff = Buffer.alloc(4);
|
|
buff.writeInt32BE(num, 0);
|
|
return buff;
|
|
}
|
|
|
|
function packUInt16LE(num) {
|
|
let buff = Buffer.alloc(2);
|
|
buff.writeUInt16LE(num, 0);
|
|
return buff;
|
|
}
|
|
|
|
function packUInt32LE(num) {
|
|
let buff = Buffer.alloc(4);
|
|
buff.writeUInt32LE(num, 0);
|
|
return buff;
|
|
}
|
|
|
|
function packUInt32BE(num) {
|
|
let buff = Buffer.alloc(4);
|
|
buff.writeUInt32BE(num, 0);
|
|
return buff;
|
|
}
|
|
|
|
function packInt64LE(num){
|
|
let buff = Buffer.alloc(8);
|
|
buff.writeUInt32LE(num % Math.pow(2, 32), 0);
|
|
buff.writeUInt32LE(Math.floor(num / Math.pow(2, 32)), 4);
|
|
return buff;
|
|
}
|
|
|
|
// Defined in bitcoin protocol here:
|
|
// https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer
|
|
function varIntBuffer(n) {
|
|
if (n < 0xfd) {
|
|
return Buffer.from([n]);
|
|
} else if (n <= 0xffff) {
|
|
let buff = Buffer.alloc(3);
|
|
buff[0] = 0xfd;
|
|
buff.writeUInt16LE(n, 1);
|
|
return buff;
|
|
} else if (n <= 0xffffffff) {
|
|
let buff = Buffer.alloc(5);
|
|
buff[0] = 0xfe;
|
|
buff.writeUInt32LE(n, 1);
|
|
return buff;
|
|
} else{
|
|
let buff = Buffer.alloc(9);
|
|
buff[0] = 0xff;
|
|
packUInt16LE(n).copy(buff, 1);
|
|
return buff;
|
|
}
|
|
}
|
|
|
|
// "serialized CScript" formatting as defined here:
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0034.mediawiki#specification
|
|
// Used to format height and date when putting into script signature:
|
|
// https://en.bitcoin.it/wiki/Script
|
|
function serializeNumber(n) {
|
|
// New version from TheSeven
|
|
if (n >= 1 && n <= 16) return Buffer.from([0x50 + n]);
|
|
var l = 1;
|
|
var buff = Buffer.alloc(9);
|
|
while (n > 0x7f) {
|
|
buff.writeUInt8(n & 0xff, l++);
|
|
n >>= 8;
|
|
}
|
|
buff.writeUInt8(l, 0);
|
|
buff.writeUInt8(n, l++);
|
|
return buff.slice(0, l);
|
|
}
|
|
|
|
// Used for serializing strings used in script signature
|
|
function serializeString(s) {
|
|
if (s.length < 253) {
|
|
return Buffer.concat([ Buffer.from([s.length]), Buffer.from(s) ]);
|
|
} else if (s.length < 0x10000) {
|
|
return Buffer.concat([ Buffer.from([253]), packUInt16LE(s.length), Buffer.from(s) ]);
|
|
} else if (s.length < 0x100000000) {
|
|
return Buffer.concat([ Buffer.from([254]), packUInt32LE(s.length), Buffer.from(s) ]);
|
|
} else {
|
|
return Buffer.concat([ Buffer.from([255]), packUInt16LE(s.length), Buffer.from(s) ]);
|
|
}
|
|
}
|
|
|
|
// An exact copy of python's range feature. Written by Tadeck:
|
|
// http://stackoverflow.com/a/8273091
|
|
function range(start, stop, step) {
|
|
if (typeof stop === 'undefined') {
|
|
stop = start;
|
|
start = 0;
|
|
}
|
|
if (typeof step === 'undefined') {
|
|
step = 1;
|
|
}
|
|
if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
|
|
return [];
|
|
}
|
|
let result = [];
|
|
for (let i = start; step > 0 ? i < stop : i > stop; i += step) {
|
|
result.push(i);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function uint256BufferFromHash(hex) {
|
|
let fromHex = Buffer.from(hex, 'hex');
|
|
if (fromHex.length != 32) {
|
|
let empty = Buffer.alloc(32);
|
|
empty.fill(0);
|
|
fromHex.copy(empty);
|
|
fromHex = empty;
|
|
}
|
|
return reverseBuffer(fromHex);
|
|
}
|
|
|
|
function getTransactionBuffers(txs) {
|
|
let txHashes = txs.map(function(tx) {
|
|
if (tx.txid !== undefined) {
|
|
return uint256BufferFromHash(tx.txid);
|
|
}
|
|
return uint256BufferFromHash(tx.hash);
|
|
});
|
|
return [null].concat(txHashes);
|
|
}
|
|
|
|
function addressToScript(addr) {
|
|
const decoded = base58.decode(addr);
|
|
if (decoded.length != 25) throw new Error('Invalid address length for ' + addr);
|
|
if (!decoded) throw new Error('Base58 decode failed for ' + addr);
|
|
const pubkey = decoded.slice(1, -4);
|
|
return Buffer.concat([Buffer.from([0x76, 0xa9, 0x14]), pubkey, Buffer.from([0x88, 0xac])]);
|
|
}
|
|
|
|
function createOutputTransaction(amount, payee, rewardToPool, reward, txOutputBuffers, payeeScript) {
|
|
const payeeReward = amount;
|
|
if (!payeeScript) payeeScript = addressToScript(payee);
|
|
txOutputBuffers.push(Buffer.concat([
|
|
packInt64LE(payeeReward),
|
|
varIntBuffer(payeeScript.length),
|
|
payeeScript
|
|
]));
|
|
return { reward: reward - amount, rewardToPool: rewardToPool - amount };
|
|
}
|
|
|
|
function generateOutputTransactions(rpcData, poolAddress) {
|
|
let reward = rpcData.coinbasevalue;
|
|
let rewardToPool = reward;
|
|
let txOutputBuffers = [];
|
|
|
|
if (rpcData.smartnode) {
|
|
if (rpcData.smartnode.payee) {
|
|
const rewards = createOutputTransaction(rpcData.smartnode.amount, rpcData.smartnode.payee, rewardToPool, reward, txOutputBuffers);
|
|
reward = rewards.reward;
|
|
rewardToPool = rewards.rewardToPool;
|
|
} else if (Array.isArray(rpcData.smartnode)) {
|
|
for (let i in rpcData.smartnode) {
|
|
const rewards = createOutputTransaction(rpcData.smartnode[i].amount, rpcData.smartnode[i].payee, rewardToPool, reward, txOutputBuffers);
|
|
reward = rewards.reward;
|
|
rewardToPool = rewards.rewardToPool;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rpcData.superblock) {
|
|
for (let i in rpcData.superblock) {
|
|
const rewards = createOutputTransaction(rpcData.superblock[i].amount, rpcData.superblock[i].payee, rewardToPool, reward, txOutputBuffers);
|
|
reward = rewards.reward;
|
|
rewardToPool = rewards.rewardToPool;
|
|
}
|
|
}
|
|
|
|
if (rpcData.founder_payments_started && rpcData.founder) {
|
|
const founderReward = rpcData.founder.amount || 0;
|
|
const rewards = createOutputTransaction(founderReward, rpcData.founder.payee, rewardToPool, reward, txOutputBuffers);
|
|
reward = rewards.reward;
|
|
rewardToPool = rewards.rewardToPool;
|
|
}
|
|
|
|
createOutputTransaction(rewardToPool, null, rewardToPool, reward, txOutputBuffers, Buffer.from(addressToScript(poolAddress), "hex"));
|
|
|
|
if (rpcData.default_witness_commitment !== undefined) {
|
|
const witness_commitment = Buffer.from(rpcData.default_witness_commitment, 'hex');
|
|
txOutputBuffers.unshift(Buffer.concat([
|
|
packInt64LE(0),
|
|
varIntBuffer(witness_commitment.length),
|
|
witness_commitment
|
|
]));
|
|
}
|
|
|
|
return Buffer.concat([ varIntBuffer(txOutputBuffers.length), Buffer.concat(txOutputBuffers)]);
|
|
}
|
|
|
|
module.exports.RtmBlockTemplate = function(rpcData, poolAddress) {
|
|
const extraNoncePlaceholderLength = 17;
|
|
const coinbaseVersion = Buffer.concat([packUInt16LE(3), packUInt16LE(5)]);
|
|
|
|
const scriptSigPart1 = Buffer.concat([
|
|
serializeNumber(rpcData.height),
|
|
Buffer.from(rpcData.coinbaseaux.flags, 'hex'),
|
|
serializeNumber(Date.now() / 1000 | 0),
|
|
Buffer.from([extraNoncePlaceholderLength])
|
|
]);
|
|
|
|
const scriptSigPart2 = serializeString('/nodeStratum/');
|
|
|
|
const blob1 = Buffer.concat([
|
|
coinbaseVersion,
|
|
// transaction input
|
|
varIntBuffer(1), // txInputsCount
|
|
uint256BufferFromHash(""), // txInPrevOutHash
|
|
packUInt32LE(Math.pow(2, 32) - 1), // txInPrevOutIndex
|
|
varIntBuffer(scriptSigPart1.length + extraNoncePlaceholderLength + scriptSigPart2.length),
|
|
scriptSigPart1
|
|
]);
|
|
|
|
let blob2 = Buffer.concat([
|
|
scriptSigPart2,
|
|
packUInt32LE(0), // txInSequence
|
|
// end transaction input
|
|
// transaction output
|
|
generateOutputTransactions(rpcData, poolAddress),
|
|
// end transaction ouput
|
|
packUInt32LE(0), // txLockTime
|
|
varIntBuffer(rpcData.coinbase_payload.length / 2),
|
|
Buffer.from(rpcData.coinbase_payload, 'hex')
|
|
]);
|
|
|
|
const prev_hash = reverseBuffer(Buffer.from(rpcData.previousblockhash, 'hex')).toString('hex');
|
|
const version = packInt32LE(rpcData.version).toString('hex');
|
|
const curtime = packUInt32LE(rpcData.curtime).toString('hex');
|
|
let bits = Buffer.from(rpcData.bits, 'hex');
|
|
bits.writeUInt32LE(bits.readUInt32BE());
|
|
let txs = [];
|
|
// skip version 1 transaction because they contain some OP_RETURN(0x6A) opcode in the beginning of
|
|
// tx input scripts instead of size of script part so not sure how to parse them
|
|
// just drop them for now
|
|
// example: https://explorer.raptoreum.com/tx/1461d70fa8362b0896e2e9be6312521f2684f22c9b0f9152695f33f67d9f9d3f
|
|
rpcData.transactions.forEach(function(tx) {
|
|
if (tx.version != 1) {
|
|
try {
|
|
bitcoin.Transaction.fromBuffer(Buffer.from(tx.data, 'hex'), false, false);
|
|
} catch(err) {
|
|
console.error("Skip RTM tx due to parse error: " + tx.data);
|
|
return; // skip transaction if it is not parsed OK (varint coding seems to be different for RTM)
|
|
}
|
|
txs.push(tx);
|
|
} else {
|
|
console.error("Skip RTM v1 tx: " + tx.data);
|
|
}
|
|
});
|
|
const txn = varIntBuffer(txs.length + 1);
|
|
|
|
return {
|
|
difficulty: parseFloat((diff1 / bignum(rpcData.target, 16).toNumber()).toFixed(9)),
|
|
height: rpcData.height,
|
|
prev_hash: prev_hash,
|
|
blocktemplate_blob: version + prev_hash + Buffer.alloc(32, 0).toString('hex') + curtime + bits.toString('hex') + Buffer.alloc(4, 0).toString('hex') +
|
|
txn.toString('hex') + blob1.toString('hex') + Buffer.alloc(extraNoncePlaceholderLength, 0xCC).toString('hex') + blob2.toString('hex') +
|
|
Buffer.concat(txs.map(function(tx) { return Buffer.from(tx.data, 'hex'); })).toString('hex'),
|
|
reserved_offset: 80 + txn.length + blob1.length
|
|
}
|
|
}
|