Source: covenants/bitfield.js

  1. 'use strict';
  3. const assert = require('bsert');
  4. const AirdropProof = require('../primitives/airdropproof');
  5. const {TREE_LEAVES} = AirdropProof;
  7. /**
  8.  * Field
  9.  */
  11. class Field {
  12.   constructor(size = 0) {
  13.     assert((size >>> 0) === size);
  15.     this.size = size;
  16.     this.field = Buffer.alloc((size + 7) >>> 3, 0x00);
  17.     this.dirty = false;
  18.   }
  20.   set(i, val) {
  21.     assert((i >>> 0) === i);
  22.     assert(i < this.size);
  23.     assert((val >>> 0) === val);
  24.     assert(val === 0 || val === 1);
  26.     if (val)
  27.       this.field[i >>> 3] |= 1 << (7 - (i & 7));
  28.     else
  29.       this.field[i >>> 3] &= ~(1 << (7 - (i & 7)));
  31.     this.dirty = true;
  33.     return this;
  34.   }
  36.   get(i) {
  37.     assert((i >>> 0) === i);
  39.     if (i >= this.size)
  40.       return 1;
  42.     return (this.field[i >>> 3] >> (7 - (i & 7))) & 1;
  43.   }
  45.   isSpent(i) {
  46.     return Boolean(this.get(i));
  47.   }
  49.   spend(i) {
  50.     return this.set(i, 1);
  51.   }
  53.   unspend(i) {
  54.     return this.set(i, 0);
  55.   }
  57.   encode() {
  58.     this.dirty = false;
  59.     return this.field;
  60.   }
  62.   decode(data) {
  63.     assert(Buffer.isBuffer(data));
  64.     this.field = data;
  65.     this.dirty = false;
  66.     return this;
  67.   }
  69.   static decode(size, data) {
  70.     return new this(size).decode(data);
  71.   }
  72. }
  74. /**
  75.  * BitField
  76.  */
  78. class BitField extends Field {
  79.   constructor() {
  80.     super(TREE_LEAVES);
  81.   }
  83.   static decode(data) {
  84.     return new this().decode(data);
  85.   }
  86. }
  88. /**
  89.  * BitView
  90.  */
  92. class BitView {
  93.   constructor() {
  94.     this.bits = new Map();
  95.   }
  97.   spend(field, tx) {
  98.     assert(field instanceof Field);
  99.     assert(tx && tx.isCoinbase());
  101.     for (let i = 1; i < tx.inputs.length; i++) {
  102.       const input = tx.inputs[i];
  103.       const output = tx.output(i);
  104.       const {witness} = input;
  106.       assert(output && witness.items.length === 1);
  108.       const {covenant} = output;
  110.       if (!covenant.isNone())
  111.         continue;
  113.       const proof = AirdropProof.decode(witness.items[0]);
  114.       const index = proof.position();
  116.       if (!this.bits.has(index))
  117.         this.bits.set(index, field.get(index));
  119.       if (this.bits.get(index) !== 0)
  120.         return false;
  122.       this.bits.set(index, 1);
  123.     }
  125.     return true;
  126.   }
  128.   undo(tx) {
  129.     assert(tx && tx.isCoinbase());
  131.     for (let i = 1; i < tx.inputs.length; i++) {
  132.       const input = tx.inputs[i];
  133.       const output = tx.output(i);
  134.       const {witness} = input;
  136.       assert(output && witness.items.length === 1);
  138.       const {covenant} = output;
  140.       if (!covenant.isNone())
  141.         continue;
  143.       const proof = AirdropProof.decode(witness.items[0]);
  144.       const index = proof.position();
  146.       this.bits.set(index, 0);
  147.     }
  149.     return this;
  150.   }
  152.   commit(field) {
  153.     assert(field instanceof Field);
  155.     for (const [bit, spent] of this.bits)
  156.       field.set(bit, spent);
  158.     return field.dirty;
  159.   }
  160. }
  162. /*
  163.  * Expose
  164.  */
  166. exports.Field = Field;
  167. exports.BitField = BitField;
  168. exports.BitView = BitView;