Source: script/stack.js

  1. /*!
  2.  * stack.js - stack object for hsd
  3.  * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
  4.  * https://github.com/handshake-org/hsd
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const bio = require('bufio');
  11. const common = require('./common');
  12. const ScriptNum = require('./scriptnum');
  14. /**
  15.  * Stack
  16.  * Represents the stack of a Script during execution.
  17.  * @alias module:script.Stack
  18.  * @property {Buffer[]} items - Stack items.
  19.  * @property {Number} length - Size of stack.
  20.  */
  22. class Stack extends bio.Struct {
  23.   /**
  24.    * Create a stack.
  25.    * @constructor
  26.    * @param {Buffer[]?} [items] - Stack items.
  27.    */
  29.   constructor(items) {
  30.     super();
  31.     this.items = items || [];
  32.   }
  34.   /**
  35.    * Get length.
  36.    * @returns {Number}
  37.    */
  39.   get length() {
  40.     return this.items.length;
  41.   }
  43.   /**
  44.    * Set length.
  45.    * @param {Number} value
  46.    */
  48.   set length(value) {
  49.     this.items.length = value;
  50.   }
  52.   /**
  53.    * Instantiate a value-only iterator.
  54.    * @returns {IterableIterator<Buffer>}
  55.    */
  57.   [Symbol.iterator]() {
  58.     return this.items[Symbol.iterator]();
  59.   }
  61.   /**
  62.    * Instantiate a value-only iterator.
  63.    * @returns {IterableIterator<Buffer>}
  64.    */
  66.   values() {
  67.     return this.items.values();
  68.   }
  70.   /**
  71.    * Instantiate a key and value iterator.
  72.    */
  74.   entries() {
  75.     return this.items.entries();
  76.   }
  78.   /**
  79.    * Inspect the stack.
  80.    * @returns {String} Human-readable stack.
  81.    */
  83.   format() {
  84.     return `<Stack: ${this.toString()}>`;
  85.   }
  87.   /**
  88.    * Convert the stack to a string.
  89.    * @returns {String} Human-readable stack.
  90.    */
  92.   toString() {
  93.     const out = [];
  95.     for (const item of this.items)
  96.       out.push(item.toString('hex'));
  98.     return out.join(' ');
  99.   }
  101.   /**
  102.    * Format the stack as bitcoind asm.
  103.    * @param {Boolean?} decode - Attempt to decode hash types.
  104.    * @returns {String} Human-readable script.
  105.    */
  107.   toASM(decode) {
  108.     const out = [];
  110.     for (const item of this.items)
  111.       out.push(common.toASM(item, decode));
  113.     return out.join(' ');
  114.   }
  116.   /**
  117.    * Clone the stack.
  118.    * @param {this} stack
  119.    * @returns {this} Cloned stack.
  120.    */
  122.   inject(stack) {
  123.     this.items = stack.items.slice();
  124.     return this;
  125.   }
  127.   /**
  128.    * Clear the stack.
  129.    * @returns {Stack}
  130.    */
  132.   clear() {
  133.     this.items.length = 0;
  134.     return this;
  135.   }
  137.   /**
  138.    * Get a stack item by index.
  139.    * @param {Number} index
  140.    * @returns {Buffer|null}
  141.    */
  143.   get(index) {
  144.     if (index < 0)
  145.       index += this.items.length;
  147.     if (index < 0 || index >= this.items.length)
  148.       return null;
  150.     return this.items[index];
  151.   }
  153.   /**
  154.    * Pop a stack item.
  155.    * @see Array#pop
  156.    * @returns {Buffer|null}
  157.    */
  159.   pop() {
  160.     const item = this.items.pop();
  161.     return item || null;
  162.   }
  164.   /**
  165.    * Shift a stack item.
  166.    * @see Array#shift
  167.    * @returns {Buffer|null}
  168.    */
  170.   shift() {
  171.     const item = this.items.shift();
  172.     return item || null;
  173.   }
  175.   /**
  176.    * Remove an item.
  177.    * @param {Number} index
  178.    * @returns {Buffer}
  179.    */
  181.   remove(index) {
  182.     if (index < 0)
  183.       index += this.items.length;
  185.     if (index < 0 || index >= this.items.length)
  186.       return null;
  188.     const items = this.items.splice(index, 1);
  190.     if (items.length === 0)
  191.       return null;
  193.     return items[0];
  194.   }
  196.   /**
  197.    * Set stack item at index.
  198.    * @param {Number} index
  199.    * @param {Buffer} item
  200.    * @returns {this}
  201.    */
  203.   set(index, item) {
  204.     if (index < 0)
  205.       index += this.items.length;
  207.     assert(Buffer.isBuffer(item));
  208.     assert(index >= 0 && index <= this.items.length);
  210.     this.items[index] = item;
  212.     return this;
  213.   }
  215.   /**
  216.    * Push item onto stack.
  217.    * @see Array#push
  218.    * @param {Buffer} item
  219.    * @returns {this}
  220.    */
  222.   push(item) {
  223.     assert(Buffer.isBuffer(item));
  224.     this.items.push(item);
  225.     return this;
  226.   }
  228.   /**
  229.    * Unshift item from stack.
  230.    * @see Array#unshift
  231.    * @param {Buffer} item
  232.    * @returns {this}
  233.    */
  235.   unshift(item) {
  236.     assert(Buffer.isBuffer(item));
  237.     this.items.unshift(item);
  238.     return this;
  239.   }
  241.   /**
  242.    * Insert an item.
  243.    * @param {Number} index
  244.    * @param {Buffer} item
  245.    * @returns {this}
  246.    */
  248.   insert(index, item) {
  249.     if (index < 0)
  250.       index += this.items.length;
  252.     assert(Buffer.isBuffer(item));
  253.     assert(index >= 0 && index <= this.items.length);
  255.     this.items.splice(index, 0, item);
  257.     return this;
  258.   }
  260.   /**
  261.    * Erase stack items.
  262.    * @param {Number} start
  263.    * @param {Number} end
  264.    * @returns {Buffer[]}
  265.    */
  267.   erase(start, end) {
  268.     if (start < 0)
  269.       start = this.items.length + start;
  271.     if (end < 0)
  272.       end = this.items.length + end;
  274.     return this.items.splice(start, end - start);
  275.   }
  277.   /**
  278.    * Swap stack values.
  279.    * @param {Number} i1 - Index 1.
  280.    * @param {Number} i2 - Index 2.
  281.    */
  283.   swap(i1, i2) {
  284.     if (i1 < 0)
  285.       i1 = this.items.length + i1;
  287.     if (i2 < 0)
  288.       i2 = this.items.length + i2;
  290.     const v1 = this.items[i1];
  291.     const v2 = this.items[i2];
  293.     this.items[i1] = v2;
  294.     this.items[i2] = v1;
  295.   }
  297.   /*
  298.    * Data
  299.    */
  301.   getData(index) {
  302.     return this.get(index);
  303.   }
  305.   popData() {
  306.     return this.pop();
  307.   }
  309.   shiftData() {
  310.     return this.shift();
  311.   }
  313.   removeData(index) {
  314.     return this.remove(index);
  315.   }
  317.   setData(index, data) {
  318.     return this.set(index, data);
  319.   }
  321.   pushData(data) {
  322.     return this.push(data);
  323.   }
  325.   unshiftData(data) {
  326.     return this.unshift(data);
  327.   }
  329.   insertData(index, data) {
  330.     return this.insert(index, data);
  331.   }
  333.   /*
  334.    * Length
  335.    */
  337.   getLength(index) {
  338.     const item = this.get(index);
  339.     return item ? item.length : -1;
  340.   }
  342.   /*
  343.    * String
  344.    */
  346.   getString(index, enc) {
  347.     const item = this.get(index);
  348.     return item ? Stack.toString(item, enc) : null;
  349.   }
  351.   popString(enc) {
  352.     const item = this.pop();
  353.     return item ? Stack.toString(item, enc) : null;
  354.   }
  356.   shiftString(enc) {
  357.     const item = this.shift();
  358.     return item ? Stack.toString(item, enc) : null;
  359.   }
  361.   removeString(index, enc) {
  362.     const item = this.remove(index);
  363.     return item ? Stack.toString(item, enc) : null;
  364.   }
  366.   setString(index, str, enc) {
  367.     return this.set(index, Stack.fromString(str, enc));
  368.   }
  370.   pushString(str, enc) {
  371.     return this.push(Stack.fromString(str, enc));
  372.   }
  374.   unshiftString(str, enc) {
  375.     return this.unshift(Stack.fromString(str, enc));
  376.   }
  378.   insertString(index, str, enc) {
  379.     return this.insert(index, Stack.fromString(str, enc));
  380.   }
  382.   /*
  383.    * Num
  384.    */
  386.   getNum(index, minimal, limit) {
  387.     const item = this.get(index);
  388.     return item ? Stack.toNum(item, minimal, limit) : null;
  389.   }
  391.   popNum(minimal, limit) {
  392.     const item = this.pop();
  393.     return item ? Stack.toNum(item, minimal, limit) : null;
  394.   }
  396.   shiftNum(minimal, limit) {
  397.     const item = this.shift();
  398.     return item ? Stack.toNum(item, minimal, limit) : null;
  399.   }
  401.   removeNum(index, minimal, limit) {
  402.     const item = this.remove(index);
  403.     return item ? Stack.toNum(item, minimal, limit) : null;
  404.   }
  406.   setNum(index, num) {
  407.     return this.set(index, Stack.fromNum(num));
  408.   }
  410.   pushNum(num) {
  411.     return this.push(Stack.fromNum(num));
  412.   }
  414.   unshiftNum(num) {
  415.     return this.unshift(Stack.fromNum(num));
  416.   }
  418.   insertNum(index, num) {
  419.     return this.insert(index, Stack.fromNum(num));
  420.   }
  422.   /*
  423.    * Int
  424.    */
  426.   getInt(index, minimal, limit) {
  427.     const item = this.get(index);
  428.     return item ? Stack.toInt(item, minimal, limit) : -1;
  429.   }
  431.   popInt(minimal, limit) {
  432.     const item = this.pop();
  433.     return item ? Stack.toInt(item, minimal, limit) : -1;
  434.   }
  436.   shiftInt(minimal, limit) {
  437.     const item = this.shift();
  438.     return item ? Stack.toInt(item, minimal, limit) : -1;
  439.   }
  441.   removeInt(index, minimal, limit) {
  442.     const item = this.remove(index);
  443.     return item ? Stack.toInt(item, minimal, limit) : -1;
  444.   }
  446.   setInt(index, num) {
  447.     return this.set(index, Stack.fromInt(num));
  448.   }
  450.   pushInt(num) {
  451.     return this.push(Stack.fromInt(num));
  452.   }
  454.   unshiftInt(num) {
  455.     return this.unshift(Stack.fromInt(num));
  456.   }
  458.   insertInt(index, num) {
  459.     return this.insert(index, Stack.fromInt(num));
  460.   }
  462.   /*
  463.    * Bool
  464.    */
  466.   getBool(index) {
  467.     const item = this.get(index);
  468.     return item ? Stack.toBool(item) : false;
  469.   }
  471.   popBool() {
  472.     const item = this.pop();
  473.     return item ? Stack.toBool(item) : false;
  474.   }
  476.   shiftBool() {
  477.     const item = this.shift();
  478.     return item ? Stack.toBool(item) : false;
  479.   }
  481.   removeBool(index) {
  482.     const item = this.remove(index);
  483.     return item ? Stack.toBool(item) : false;
  484.   }
  486.   setBool(index, value) {
  487.     return this.set(index, Stack.fromBool(value));
  488.   }
  490.   pushBool(value) {
  491.     return this.push(Stack.fromBool(value));
  492.   }
  494.   unshiftBool(value) {
  495.     return this.unshift(Stack.fromBool(value));
  496.   }
  498.   insertBool(index, value) {
  499.     return this.insert(index, Stack.fromBool(value));
  500.   }
  502.   /**
  503.    * Test an object to see if it is a Stack.
  504.    * @param {Object} obj
  505.    * @returns {Boolean}
  506.    */
  508.   static isStack(obj) {
  509.     return obj instanceof Stack;
  510.   }
  512.   /*
  513.    * Encoding
  514.    */
  516.   static toString(item, enc) {
  517.     assert(Buffer.isBuffer(item));
  518.     return item.toString(enc || 'utf8');
  519.   }
  521.   static fromString(str, enc) {
  522.     assert(typeof str === 'string');
  523.     return Buffer.from(str, enc || 'utf8');
  524.   }
  526.   static toNum(item, minimal, limit) {
  527.     return ScriptNum.decode(item, minimal, limit);
  528.   }
  530.   static fromNum(num) {
  531.     assert(ScriptNum.isScriptNum(num));
  532.     return num.encode();
  533.   }
  535.   static toInt(item, minimal, limit) {
  536.     const num = Stack.toNum(item, minimal, limit);
  537.     return num.getInt();
  538.   }
  540.   static fromInt(int) {
  541.     assert(typeof int === 'number');
  543.     if (int >= -1 && int <= 16)
  544.       return common.small[int + 1];
  546.     const num = ScriptNum.fromNumber(int);
  548.     return Stack.fromNum(num);
  549.   }
  551.   static toBool(item) {
  552.     assert(Buffer.isBuffer(item));
  554.     for (let i = 0; i < item.length; i++) {
  555.       if (item[i] !== 0) {
  556.         // Cannot be negative zero
  557.         if (i === item.length - 1 && item[i] === 0x80)
  558.           return false;
  559.         return true;
  560.       }
  561.     }
  563.     return false;
  564.   }
  566.   static fromBool(value) {
  567.     assert(typeof value === 'boolean');
  568.     return Stack.fromInt(value ? 1 : 0);
  569.   }
  570. }
  572. /*
  573.  * Expose
  574.  */
  576. module.exports = Stack;