Source: workers/packets.js

  1. /*!
  2.  * packets.js - worker packets for hsd
  3.  * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
  4.  * https://github.com/handshake-org/hsd
  5.  */
  7. 'use strict';
  9. /**
  10.  * @module workers/packets
  11.  */
  13. const assert = require('bsert');
  14. const bio = require('bufio');
  15. const Witness = require('../script/witness');
  16. const Output = require('../primitives/output');
  17. const MTX = require('../primitives/mtx');
  18. const TX = require('../primitives/tx');
  19. const KeyRing = require('../primitives/keyring');
  20. const CoinView = require('../coins/coinview');
  21. const ScriptError = require('../script/scripterror');
  22. const {encoding} = bio;
  24. /*
  25.  * Constants
  26.  */
  28. const packetTypes = {
  29.   ENV: 0,
  30.   EVENT: 1,
  31.   LOG: 2,
  32.   ERROR: 3,
  33.   ERRORRESULT: 4,
  34.   CHECK: 5,
  35.   CHECKRESULT: 6,
  36.   SIGN: 7,
  37.   SIGNRESULT: 8,
  38.   CHECKINPUT: 9,
  39.   CHECKINPUTRESULT: 10,
  40.   SIGNINPUT: 11,
  41.   SIGNINPUTRESULT: 12,
  42.   ECVERIFY: 13,
  43.   ECVERIFYRESULT: 14,
  44.   ECSIGN: 15,
  45.   ECSIGNRESULT: 16,
  46.   MINE: 17,
  47.   MINERESULT: 18,
  48.   SCRYPT: 19,
  49.   SCRYPTRESULT: 20
  50. };
  52. /**
  53.  * Packet
  54.  */
  56. class Packet extends bio.Struct {
  57.   constructor() {
  58.     super();
  59.     this.id = ++Packet.id >>> 0;
  60.     this.cmd = -1;
  61.   }
  63.   getSize() {
  64.     throw new Error('Abstract method.');
  65.   }
  67.   write(bw) {
  68.     throw new Error('Abstract method.');
  69.   }
  71.   read(br) {
  72.     throw new Error('Abstract method.');
  73.   }
  75.   decode(data, extra) {
  76.     const br = bio.read(data, true);
  77.     this.read(br, extra);
  78.     return this;
  79.   }
  80. }
  82. Packet.id = 0;
  84. /**
  85.  * EnvPacket
  86.  */
  88. class EnvPacket extends Packet {
  89.   constructor(env) {
  90.     super();
  91.     this.cmd = packetTypes.ENV;
  92.     this.env = env || {};
  93.     this.json = JSON.stringify(this.env);
  94.   }
  96.   getSize() {
  97.     return encoding.sizeVarString(this.json, 'utf8');
  98.   }
  100.   write(bw) {
  101.     bw.writeVarString(this.json, 'utf8');
  102.     return bw;
  103.   }
  105.   read(br) {
  106.     this.json = br.readVarString('utf8');
  107.     this.env = JSON.parse(this.json);
  108.     return this;
  109.   }
  110. }
  112. /**
  113.  * EventPacket
  114.  */
  116. class EventPacket extends Packet {
  117.   constructor(items) {
  118.     super();
  119.     this.cmd = packetTypes.EVENT;
  120.     this.items = items || [];
  121.     this.json = JSON.stringify(this.items);
  122.   }
  124.   getSize() {
  125.     return encoding.sizeVarString(this.json, 'utf8');
  126.   }
  128.   write(bw) {
  129.     bw.writeVarString(this.json, 'utf8');
  130.     return bw;
  131.   }
  133.   read(br) {
  134.     this.json = br.readVarString('utf8');
  135.     this.items = JSON.parse(this.json);
  136.     return this;
  137.   }
  138. }
  140. /**
  141.  * LogPacket
  142.  */
  144. class LogPacket extends Packet {
  145.   constructor(text) {
  146.     super();
  147.     this.cmd = packetTypes.LOG;
  148.     this.text = text || '';
  149.   }
  151.   getSize() {
  152.     return encoding.sizeVarString(this.text, 'utf8');
  153.   }
  155.   write(bw) {
  156.     bw.writeVarString(this.text, 'utf8');
  157.     return bw;
  158.   }
  160.   read(br) {
  161.     this.text = br.readVarString('utf8');
  162.     return this;
  163.   }
  164. }
  166. /**
  167.  * ErrorPacket
  168.  */
  170. class ErrorPacket extends Packet {
  171.   constructor(error) {
  172.     super();
  173.     this.cmd = packetTypes.ERROR;
  174.     this.error = error || new Error();
  175.   }
  177.   getSize() {
  178.     const err = this.error;
  180.     let size = 0;
  182.     size += encoding.sizeVarString(stringify(err.message), 'utf8');
  183.     size += encoding.sizeVarString(stringify(err.stack), 'utf8');
  184.     size += encoding.sizeVarString(stringify(err.type), 'utf8');
  186.     switch (typeof err.code) {
  187.       case 'number':
  188.         size += 1;
  189.         size += 4;
  190.         break;
  191.       case 'string':
  192.         size += 1;
  193.         size += encoding.sizeVarString(err.code, 'utf8');
  194.         break;
  195.       default:
  196.         size += 1;
  197.         break;
  198.     }
  200.     return size;
  201.   }
  203.   write(bw) {
  204.     const err = this.error;
  206.     bw.writeVarString(stringify(err.message), 'utf8');
  207.     bw.writeVarString(stringify(err.stack), 'utf8');
  208.     bw.writeVarString(stringify(err.type), 'utf8');
  210.     switch (typeof err.code) {
  211.       case 'number':
  212.         bw.writeU8(2);
  213.         bw.writeI32(err.code);
  214.         break;
  215.       case 'string':
  216.         bw.writeU8(1);
  217.         bw.writeVarString(err.code, 'utf8');
  218.         break;
  219.       default:
  220.         bw.writeU8(0);
  221.         break;
  222.     }
  224.     return bw;
  225.   }
  227.   read(br) {
  228.     const err = this.error;
  230.     err.message = br.readVarString('utf8');
  231.     err.stack = br.readVarString('utf8');
  232.     err.type = br.readVarString('utf8');
  234.     switch (br.readU8()) {
  235.       case 2:
  236.         err.code = br.readI32();
  237.         break;
  238.       case 1:
  239.         err.code = br.readVarString('utf8');
  240.         break;
  241.       default:
  242.         err.code = null;
  243.         break;
  244.     }
  246.     return this;
  247.   }
  248. }
  250. /**
  251.  * ErrorResultPacket
  252.  */
  254. class ErrorResultPacket extends ErrorPacket {
  255.   constructor(error) {
  256.     super(error);
  257.     this.cmd = packetTypes.ERRORRESULT;
  258.   }
  259. }
  261. /**
  262.  * CheckPacket
  263.  */
  265. class CheckPacket extends Packet {
  266.   constructor(tx, view, flags) {
  267.     super();
  268.     this.cmd = packetTypes.CHECK;
  269.     this.tx = tx || null;
  270.     this.view = view || null;
  271.     this.flags = flags != null ? flags : null;
  272.   }
  274.   getSize() {
  275.     return this.tx.getSize() + this.view.getSize(this.tx) + 4;
  276.   }
  278.   write(bw) {
  279.     this.tx.write(bw);
  280.     this.view.write(bw, this.tx);
  281.     bw.writeI32(this.flags != null ? this.flags : -1);
  282.     return bw;
  283.   }
  285.   read(br) {
  286.     this.tx = TX.read(br);
  287.     this.view = CoinView.read(br, this.tx);
  288.     this.flags = br.readI32();
  290.     if (this.flags === -1)
  291.       this.flags = null;
  293.     return this;
  294.   }
  295. }
  297. /**
  298.  * CheckResultPacket
  299.  */
  301. class CheckResultPacket extends Packet {
  302.   constructor(error) {
  303.     super();
  304.     this.cmd = packetTypes.CHECKRESULT;
  305.     this.error = error || null;
  306.   }
  308.   getSize() {
  309.     const err = this.error;
  311.     let size = 0;
  313.     if (!err) {
  314.       size += 1;
  315.       return size;
  316.     }
  318.     size += 1;
  319.     size += encoding.sizeVarString(stringify(err.message), 'utf8');
  320.     size += encoding.sizeVarString(stringify(err.stack), 'utf8');
  321.     size += encoding.sizeVarString(stringify(err.code), 'utf8');
  322.     size += 1;
  323.     size += 4;
  325.     return size;
  326.   }
  328.   write(bw) {
  329.     const err = this.error;
  331.     if (!err) {
  332.       bw.writeU8(0);
  333.       return bw;
  334.     }
  336.     bw.writeU8(1);
  337.     bw.writeVarString(stringify(err.message), 'utf8');
  338.     bw.writeVarString(stringify(err.stack), 'utf8');
  339.     bw.writeVarString(stringify(err.code), 'utf8');
  340.     bw.writeU8(err.op === -1 ? 0xff : err.op);
  341.     bw.writeU32(err.ip === -1 ? 0xffffffff : err.ip);
  343.     return bw;
  344.   }
  346.   read(br) {
  347.     if (br.readU8() === 0)
  348.       return this;
  350.     const err = new ScriptError('');
  352.     err.message = br.readVarString('utf8');
  353.     err.stack = br.readVarString('utf8');
  354.     err.code = br.readVarString('utf8');
  355.     err.op = br.readU8();
  356.     err.ip = br.readU32();
  358.     if (err.op === 0xff)
  359.       err.op = -1;
  361.     if (err.ip === 0xffffffff)
  362.       err.ip = -1;
  364.     this.error = err;
  366.     return this;
  367.   }
  368. }
  370. /**
  371.  * SignPacket
  372.  */
  374. class SignPacket extends Packet {
  375.   constructor(tx, rings, type) {
  376.     super();
  377.     this.cmd = packetTypes.SIGN;
  378.     this.tx = tx || null;
  379.     this.rings = rings || [];
  380.     this.type = type != null ? type : 1;
  381.   }
  383.   getSize() {
  384.     let size = 0;
  386.     size += this.tx.getSize();
  387.     size += this.tx.view.getSize(this.tx);
  388.     size += encoding.sizeVarint(this.rings.length);
  390.     for (const ring of this.rings)
  391.       size += ring.getSize();
  393.     size += 1;
  395.     return size;
  396.   }
  398.   write(bw) {
  399.     this.tx.write(bw);
  400.     this.tx.view.write(bw, this.tx);
  402.     bw.writeVarint(this.rings.length);
  404.     for (const ring of this.rings)
  405.       ring.write(bw);
  407.     bw.writeU8(this.type);
  409.     return bw;
  410.   }
  412.   read(br) {
  413.     this.tx = MTX.read(br);
  414.     this.tx.view.read(br, this.tx);
  416.     const count = br.readVarint();
  418.     for (let i = 0; i < count; i++) {
  419.       const ring = KeyRing.read(br);
  420.       this.rings.push(ring);
  421.     }
  423.     this.type = br.readU8();
  425.     return this;
  426.   }
  427. }
  429. /**
  430.  * SignResultPacket
  431.  */
  433. class SignResultPacket extends Packet {
  434.   constructor(total, witness, script) {
  435.     super();
  436.     this.cmd = packetTypes.SIGNRESULT;
  437.     this.total = total || 0;
  438.     this.witness = witness || [];
  439.   }
  441.   fromTX(tx, total) {
  442.     this.total = total;
  444.     for (const input of tx.inputs)
  445.       this.witness.push(input.witness);
  447.     return this;
  448.   }
  450.   static fromTX(tx, total) {
  451.     return new SignResultPacket().fromTX(tx, total);
  452.   }
  454.   getSize() {
  455.     let size = 0;
  457.     size += encoding.sizeVarint(this.total);
  458.     size += encoding.sizeVarint(this.witness.length);
  460.     for (let i = 0; i < this.witness.length; i++) {
  461.       const witness = this.witness[i];
  462.       size += witness.getVarSize();
  463.     }
  465.     return size;
  466.   }
  468.   write(bw) {
  469.     bw.writeVarint(this.total);
  470.     bw.writeVarint(this.witness.length);
  472.     for (let i = 0; i < this.witness.length; i++)
  473.       this.witness[i].write(bw);
  475.     return bw;
  476.   }
  478.   inject(tx) {
  479.     assert(this.witness.length === tx.inputs.length);
  481.     for (let i = 0; i < tx.inputs.length; i++) {
  482.       const input = tx.inputs[i];
  483.       input.witness = this.witness[i];
  484.     }
  485.   }
  487.   read(br) {
  488.     this.total = br.readVarint();
  490.     const count = br.readVarint();
  492.     for (let i = 0; i < count; i++)
  493.       this.witness.push(Witness.read(br));
  495.     return this;
  496.   }
  497. }
  499. /**
  500.  * CheckInputPacket
  501.  */
  503. class CheckInputPacket extends Packet {
  504.   constructor(tx, index, coin, flags) {
  505.     super();
  506.     this.cmd = packetTypes.CHECKINPUT;
  507.     this.tx = tx || null;
  508.     this.index = index;
  509.     this.coin = coin || null;
  510.     this.flags = flags != null ? flags : null;
  511.   }
  513.   getSize() {
  514.     let size = 0;
  515.     size += this.tx.getSize();
  516.     size += encoding.sizeVarint(this.index);
  517.     size += encoding.sizeVarint(this.coin.value);
  518.     size += this.coin.script.getVarSize();
  519.     size += 4;
  520.     return size;
  521.   }
  523.   write(bw) {
  524.     this.tx.write(bw);
  525.     bw.writeVarint(this.index);
  526.     bw.writeVarint(this.coin.value);
  527.     this.coin.script.write(bw);
  528.     bw.writeI32(this.flags != null ? this.flags : -1);
  529.     return bw;
  530.   }
  532.   read(br) {
  533.     this.tx = TX.read(br);
  534.     this.index = br.readVarint();
  536.     this.coin = new Output();
  537.     this.coin.value = br.readVarint();
  538.     this.coin.script.read(br);
  540.     this.flags = br.readI32();
  542.     if (this.flags === -1)
  543.       this.flags = null;
  545.     return this;
  546.   }
  547. }
  549. /**
  550.  * CheckInputResultPacket
  551.  */
  553. class CheckInputResultPacket extends CheckResultPacket {
  554.   constructor(error) {
  555.     super(error);
  556.     this.cmd = packetTypes.CHECKINPUTRESULT;
  557.   }
  558. }
  560. /**
  561.  * SignInputPacket
  562.  */
  564. class SignInputPacket extends Packet {
  565.   constructor(tx, index, coin, ring, type) {
  566.     super();
  567.     this.cmd = packetTypes.SIGNINPUT;
  568.     this.tx = tx || null;
  569.     this.index = index;
  570.     this.coin = coin || null;
  571.     this.ring = ring || null;
  572.     this.type = type != null ? type : 1;
  573.   }
  575.   getSize() {
  576.     let size = 0;
  577.     size += this.tx.getSize();
  578.     size += encoding.sizeVarint(this.index);
  579.     size += encoding.sizeVarint(this.coin.value);
  580.     size += this.coin.script.getVarSize();
  581.     size += this.ring.getSize();
  582.     size += 1;
  583.     return size;
  584.   }
  586.   write(bw) {
  587.     this.tx.write(bw);
  588.     bw.writeVarint(this.index);
  589.     bw.writeVarint(this.coin.value);
  590.     this.coin.script.write(bw);
  591.     this.ring.write(bw);
  592.     bw.writeU8(this.type);
  593.     return bw;
  594.   }
  596.   read(br) {
  597.     this.tx = MTX.read(br);
  598.     this.index = br.readVarint();
  600.     this.coin = new Output();
  601.     this.coin.value = br.readVarint();
  602.     this.coin.script.read(br);
  604.     this.ring = KeyRing.read(br);
  605.     this.type = br.readU8();
  607.     return this;
  608.   }
  609. }
  611. /**
  612.  * SignInputResultPacket
  613.  */
  615. class SignInputResultPacket extends Packet {
  616.   constructor(value, witness) {
  617.     super();
  618.     this.cmd = packetTypes.SIGNINPUTRESULT;
  619.     this.value = value || false;
  620.     this.witness = witness || null;
  621.   }
  623.   fromTX(tx, i, value) {
  624.     const input = tx.inputs[i];
  626.     assert(input);
  628.     this.value = value;
  629.     this.witness = input.witness;
  631.     return this;
  632.   }
  634.   static fromTX(tx, i, value) {
  635.     return new SignInputResultPacket().fromTX(tx, i, value);
  636.   }
  638.   getSize() {
  639.     return 1 + this.witness.getVarSize();
  640.   }
  642.   write(bw) {
  643.     bw.writeU8(this.value ? 1 : 0);
  644.     this.witness.write(bw);
  645.     return bw;
  646.   }
  648.   inject(tx, i) {
  649.     const input = tx.inputs[i];
  650.     assert(input);
  651.     input.witness = this.witness;
  652.   }
  654.   read(br) {
  655.     this.value = br.readU8() === 1;
  656.     this.witness = Witness.read(br);
  657.     return this;
  658.   }
  659. }
  661. /**
  662.  * ECVerifyPacket
  663.  */
  665. class ECVerifyPacket extends Packet {
  666.   constructor(msg, sig, key) {
  667.     super();
  668.     this.cmd = packetTypes.ECVERIFY;
  669.     this.msg = msg || null;
  670.     this.sig = sig || null;
  671.     this.key = key || null;
  672.   }
  674.   getSize() {
  675.     let size = 0;
  676.     size += encoding.sizeVarBytes(this.msg);
  677.     size += encoding.sizeVarBytes(this.sig);
  678.     size += encoding.sizeVarBytes(this.key);
  679.     return size;
  680.   }
  682.   write(bw) {
  683.     bw.writeVarBytes(this.msg);
  684.     bw.writeVarBytes(this.sig);
  685.     bw.writeVarBytes(this.key);
  686.     return bw;
  687.   }
  689.   read(br) {
  690.     this.msg = br.readVarBytes();
  691.     this.sig = br.readVarBytes();
  692.     this.key = br.readVarBytes();
  693.     return this;
  694.   }
  695. }
  697. /**
  698.  * ECVerifyResultPacket
  699.  */
  701. class ECVerifyResultPacket extends Packet {
  702.   constructor(value) {
  703.     super();
  704.     this.cmd = packetTypes.ECVERIFYRESULT;
  705.     this.value = value;
  706.   }
  708.   getSize() {
  709.     return 1;
  710.   }
  712.   write(bw) {
  713.     bw.writeU8(this.value ? 1 : 0);
  714.     return bw;
  715.   }
  717.   read(br) {
  718.     this.value = br.readU8() === 1;
  719.     return this;
  720.   }
  721. }
  723. /**
  724.  * ECSignPacket
  725.  */
  727. class ECSignPacket extends Packet {
  728.   constructor(msg, key) {
  729.     super();
  730.     this.cmd = packetTypes.ECSIGN;
  731.     this.msg = msg || null;
  732.     this.key = key || null;
  733.   }
  735.   getSize() {
  736.     let size = 0;
  737.     size += encoding.sizeVarBytes(this.msg);
  738.     size += encoding.sizeVarBytes(this.key);
  739.     return size;
  740.   }
  742.   write(bw) {
  743.     bw.writeVarBytes(this.msg);
  744.     bw.writeVarBytes(this.key);
  745.     return bw;
  746.   }
  748.   read(br) {
  749.     this.msg = br.readVarBytes();
  750.     this.key = br.readVarBytes();
  751.     return this;
  752.   }
  753. }
  755. /**
  756.  * ECSignResultPacket
  757.  */
  759. class ECSignResultPacket extends Packet {
  760.   constructor(sig) {
  761.     super();
  762.     this.cmd = packetTypes.ECSIGNRESULT;
  763.     this.sig = sig;
  764.   }
  766.   getSize() {
  767.     return encoding.sizeVarBytes(this.sig);
  768.   }
  770.   write(bw) {
  771.     bw.writeVarBytes(this.sig);
  772.     return bw;
  773.   }
  775.   read(br) {
  776.     this.sig = br.readVarBytes();
  777.     return this;
  778.   }
  779. }
  781. /**
  782.  * MinePacket
  783.  */
  785. class MinePacket extends Packet {
  786.   constructor(hdr, target, rounds) {
  787.     super();
  788.     this.cmd = packetTypes.MINE;
  789.     this.hdr = hdr || null;
  790.     this.target = target || null;
  791.     this.rounds = rounds != null ? rounds : -1;
  792.   }
  794.   getSize() {
  795.     return 256 + 32 + 4;
  796.   }
  798.   write(bw) {
  799.     bw.writeBytes(this.hdr);
  800.     bw.writeBytes(this.target);
  801.     bw.writeU32(this.rounds);
  802.     return bw;
  803.   }
  805.   read(br) {
  806.     this.hdr = br.readBytes(256);
  807.     this.target = br.readBytes(32);
  808.     this.rounds = br.readU32();
  809.     return this;
  810.   }
  811. }
  813. /**
  814.  * MineResultPacket
  815.  */
  817. class MineResultPacket extends Packet {
  818.   constructor(nonce, solved) {
  819.     super();
  820.     this.cmd = packetTypes.MINERESULT;
  821.     this.nonce = nonce || 0;
  822.     this.solved = solved || false;
  823.   }
  825.   getSize() {
  826.     return 4 + 1;
  827.   }
  829.   write(bw) {
  830.     bw.writeU32(this.nonce);
  831.     bw.writeU8(this.solved ? 1 : 0);
  832.     return bw;
  833.   }
  835.   read(br) {
  836.     this.nonce = br.readU32();
  837.     this.solved = br.readU8() === 1;
  838.     return this;
  839.   }
  840. }
  842. /**
  843.  * ScryptPacket
  844.  */
  846. class ScryptPacket extends Packet {
  847.   constructor(passwd, salt, N, r, p, len) {
  848.     super();
  849.     this.cmd = packetTypes.SCRYPT;
  850.     this.passwd = passwd || null;
  851.     this.salt = salt || null;
  852.     this.N = N != null ? N : -1;
  853.     this.r = r != null ? r : -1;
  854.     this.p = p != null ? p : -1;
  855.     this.len = len != null ? len : -1;
  856.   }
  858.   getSize() {
  859.     let size = 0;
  860.     size += encoding.sizeVarBytes(this.passwd);
  861.     size += encoding.sizeVarBytes(this.salt);
  862.     size += 16;
  863.     return size;
  864.   }
  866.   write(bw) {
  867.     bw.writeVarBytes(this.passwd);
  868.     bw.writeVarBytes(this.salt);
  869.     bw.writeU32(this.N);
  870.     bw.writeU32(this.r);
  871.     bw.writeU32(this.p);
  872.     bw.writeU32(this.len);
  873.     return bw;
  874.   }
  876.   read(br) {
  877.     this.passwd = br.readVarBytes();
  878.     this.salt = br.readVarBytes();
  879.     this.N = br.readU32();
  880.     this.r = br.readU32();
  881.     this.p = br.readU32();
  882.     this.len = br.readU32();
  883.     return this;
  884.   }
  885. }
  887. /**
  888.  * ScryptResultPacket
  889.  */
  891. class ScryptResultPacket extends Packet {
  892.   constructor(key) {
  893.     super();
  894.     this.cmd = packetTypes.SCRYPTRESULT;
  895.     this.key = key || null;
  896.   }
  898.   getSize() {
  899.     return encoding.sizeVarBytes(this.key);
  900.   }
  902.   write(bw) {
  903.     bw.writeVarBytes(this.key);
  904.     return bw;
  905.   }
  907.   read(br) {
  908.     this.key = br.readVarBytes();
  909.     return this;
  910.   }
  911. }
  913. /*
  914.  * Helpers
  915.  */
  917. function stringify(value) {
  918.   if (typeof value !== 'string')
  919.     return '';
  920.   return value;
  921. }
  923. /*
  924.  * Expose
  925.  */
  927. exports.types = packetTypes;
  928. exports.EnvPacket = EnvPacket;
  929. exports.EventPacket = EventPacket;
  930. exports.LogPacket = LogPacket;
  931. exports.ErrorPacket = ErrorPacket;
  932. exports.ErrorResultPacket = ErrorResultPacket;
  933. exports.CheckPacket = CheckPacket;
  934. exports.CheckResultPacket = CheckResultPacket;
  935. exports.SignPacket = SignPacket;
  936. exports.SignResultPacket = SignResultPacket;
  937. exports.CheckInputPacket = CheckInputPacket;
  938. exports.CheckInputResultPacket = CheckInputResultPacket;
  939. exports.SignInputPacket = SignInputPacket;
  940. exports.SignInputResultPacket = SignInputResultPacket;
  941. exports.ECVerifyPacket = ECVerifyPacket;
  942. exports.ECVerifyResultPacket = ECVerifyResultPacket;
  943. exports.ECSignPacket = ECSignPacket;
  944. exports.ECSignResultPacket = ECSignResultPacket;
  945. exports.MinePacket = MinePacket;
  946. exports.MineResultPacket = MineResultPacket;
  947. exports.ScryptPacket = ScryptPacket;
  948. exports.ScryptResultPacket = ScryptResultPacket;