Source: script/script.js

  1. /*!
  2.  * script.js - script interpreter for bcoin
  3.  * Copyright (c) 2014-2015, Fedor Indutny (MIT License)
  4.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  5.  * https://github.com/bcoin-org/bcoin
  6.  */
  8. 'use strict';
  10. const assert = require('bsert');
  11. const bio = require('bufio');
  12. const ripemd160 = require('bcrypto/lib/ripemd160');
  13. const sha1 = require('bcrypto/lib/sha1');
  14. const sha256 = require('bcrypto/lib/sha256');
  15. const hash160 = require('bcrypto/lib/hash160');
  16. const hash256 = require('bcrypto/lib/hash256');
  17. const secp256k1 = require('bcrypto/lib/secp256k1');
  18. const consensus = require('../protocol/consensus');
  19. const policy = require('../protocol/policy');
  20. const Program = require('./program');
  21. const Opcode = require('./opcode');
  22. const Stack = require('./stack');
  23. const ScriptError = require('./scripterror');
  24. const ScriptNum = require('./scriptnum');
  25. const common = require('./common');
  26. const Address = require('../primitives/address');
  27. const opcodes = common.opcodes;
  28. const scriptTypes = common.types;
  29. const {encoding} = bio;
  30. const {inspectSymbol} = require('../utils');
  32. /*
  33.  * Constants
  34.  */
  36. const EMPTY_BUFFER = Buffer.alloc(0);
  38. /**
  39.  * Script
  40.  * Represents a input or output script.
  41.  * @alias module:script.Script
  42.  * @property {Array} code - Parsed script code.
  43.  * @property {Buffer?} raw - Serialized script.
  44.  * @property {Number} length - Number of parsed opcodes.
  45.  */
  47. class Script {
  48.   /**
  49.    * Create a script.
  50.    * @constructor
  51.    * @param {Buffer|Array|Object} code
  52.    */
  54.   constructor(options) {
  55.     this.raw = EMPTY_BUFFER;
  56.     this.code = [];
  58.     if (options)
  59.       this.fromOptions(options);
  60.   }
  62.   /**
  63.    * Get length.
  64.    * @returns {Number}
  65.    */
  67.   get length() {
  68.     return this.code.length;
  69.   }
  71.   /**
  72.    * Set length.
  73.    * @param {Number} value
  74.    */
  76.   set length(value) {
  77.     this.code.length = value;
  78.   }
  80.   /**
  81.    * Inject properties from options object.
  82.    * @private
  83.    * @param {Object} options
  84.    */
  86.   fromOptions(options) {
  87.     assert(options, 'Script data is required.');
  89.     if (Buffer.isBuffer(options))
  90.       return this.fromRaw(options);
  92.     if (Array.isArray(options))
  93.       return this.fromArray(options);
  95.     if (options.raw) {
  96.       if (!options.code)
  97.         return this.fromRaw(options.raw);
  98.       assert(Buffer.isBuffer(options.raw), 'Raw must be a Buffer.');
  99.       this.raw = options.raw;
  100.     }
  102.     if (options.code) {
  103.       if (!options.raw)
  104.         return this.fromArray(options.code);
  105.       assert(Array.isArray(options.code), 'Code must be an array.');
  106.       this.code = options.code;
  107.     }
  109.     return this;
  110.   }
  112.   /**
  113.    * Insantiate script from options object.
  114.    * @param {Object} options
  115.    * @returns {Script}
  116.    */
  118.   static fromOptions(options) {
  119.     return new this().fromOptions(options);
  120.   }
  122.   /**
  123.    * Instantiate a value-only iterator.
  124.    * @returns {ScriptIterator}
  125.    */
  127.   values() {
  128.     return this.code.values();
  129.   }
  131.   /**
  132.    * Instantiate a key and value iterator.
  133.    * @returns {ScriptIterator}
  134.    */
  136.   entries() {
  137.     return this.code.entries();
  138.   }
  140.   /**
  141.    * Instantiate a value-only iterator.
  142.    * @returns {ScriptIterator}
  143.    */
  145.   [Symbol.iterator]() {
  146.     return this.code[Symbol.iterator]();
  147.   }
  149.   /**
  150.    * Convert the script to an array of
  151.    * Buffers (pushdatas) and Numbers
  152.    * (opcodes).
  153.    * @returns {Array}
  154.    */
  156.   toArray() {
  157.     return this.code.slice();
  158.   }
  160.   /**
  161.    * Inject properties from an array of
  162.    * of buffers and numbers.
  163.    * @private
  164.    * @param {Array} code
  165.    * @returns {Script}
  166.    */
  168.   fromArray(code) {
  169.     assert(Array.isArray(code));
  171.     this.clear();
  173.     for (const op of code)
  174.       this.push(op);
  176.     return this.compile();
  177.   }
  179.   /**
  180.    * Instantiate script from an array
  181.    * of buffers and numbers.
  182.    * @param {Array} code
  183.    * @returns {Script}
  184.    */
  186.   static fromArray(code) {
  187.     return new this().fromArray(code);
  188.   }
  190.   /**
  191.    * Convert script to stack items.
  192.    * @returns {Buffer[]}
  193.    */
  195.   toItems() {
  196.     const items = [];
  198.     for (const op of this.code) {
  199.       const data = op.toPush();
  201.       if (!data)
  202.         throw new Error('Non-push opcode in script.');
  204.       items.push(data);
  205.     }
  207.     return items;
  208.   }
  210.   /**
  211.    * Inject data from stack items.
  212.    * @private
  213.    * @param {Buffer[]} items
  214.    * @returns {Script}
  215.    */
  217.   fromItems(items) {
  218.     assert(Array.isArray(items));
  220.     this.clear();
  222.     for (const item of items)
  223.       this.pushData(item);
  225.     return this.compile();
  226.   }
  228.   /**
  229.    * Instantiate script from stack items.
  230.    * @param {Buffer[]} items
  231.    * @returns {Script}
  232.    */
  234.   static fromItems(items) {
  235.     return new this().fromItems(items);
  236.   }
  238.   /**
  239.    * Convert script to stack.
  240.    * @returns {Stack}
  241.    */
  243.   toStack() {
  244.     return new Stack(this.toItems());
  245.   }
  247.   /**
  248.    * Inject data from stack.
  249.    * @private
  250.    * @param {Stack} stack
  251.    * @returns {Script}
  252.    */
  254.   fromStack(stack) {
  255.     return this.fromItems(stack.items);
  256.   }
  258.   /**
  259.    * Instantiate script from stack.
  260.    * @param {Stack} stack
  261.    * @returns {Script}
  262.    */
  264.   static fromStack(stack) {
  265.     return new this().fromStack(stack);
  266.   }
  268.   /**
  269.    * Clone the script.
  270.    * @returns {Script} Cloned script.
  271.    */
  273.   clone() {
  274.     return new this.constructor().inject(this);
  275.   }
  277.   /**
  278.    * Inject properties from script.
  279.    * Used for cloning.
  280.    * @private
  281.    * @param {Script} script
  282.    * @returns {Script}
  283.    */
  285.   inject(script) {
  286.     this.raw = script.raw;
  287.     this.code = script.code.slice();
  288.     return this;
  289.   }
  291.   /**
  292.    * Test equality against script.
  293.    * @param {Script} script
  294.    * @returns {Boolean}
  295.    */
  297.   equals(script) {
  298.     assert(Script.isScript(script));
  299.     return this.raw.equals(script.raw);
  300.   }
  302.   /**
  303.    * Compare against another script.
  304.    * @param {Script} script
  305.    * @returns {Number}
  306.    */
  308.   compare(script) {
  309.     assert(Script.isScript(script));
  310.     return this.raw.compare(script.raw);
  311.   }
  313.   /**
  314.    * Clear the script.
  315.    * @returns {Script}
  316.    */
  318.   clear() {
  319.     this.raw = EMPTY_BUFFER;
  320.     this.code.length = 0;
  321.     return this;
  322.   }
  324.   /**
  325.    * Inspect the script.
  326.    * @returns {String} Human-readable script code.
  327.    */
  329.   [inspectSymbol]() {
  330.     return `<Script: ${this.toString()}>`;
  331.   }
  333.   /**
  334.    * Convert the script to a bitcoind test string.
  335.    * @returns {String} Human-readable script code.
  336.    */
  338.   toString() {
  339.     const out = [];
  341.     for (const op of this.code)
  342.       out.push(op.toFormat());
  344.     return out.join(' ');
  345.   }
  347.   /**
  348.    * Format the script as bitcoind asm.
  349.    * @param {Boolean?} decode - Attempt to decode hash types.
  350.    * @returns {String} Human-readable script.
  351.    */
  353.   toASM(decode) {
  354.     if (this.isNulldata())
  355.       decode = false;
  357.     const out = [];
  359.     for (const op of this.code)
  360.       out.push(op.toASM(decode));
  362.     return out.join(' ');
  363.   }
  365.   /**
  366.    * Re-encode the script internally. Useful if you
  367.    * changed something manually in the `code` array.
  368.    * @returns {Script}
  369.    */
  371.   compile() {
  372.     if (this.code.length === 0)
  373.       return this.clear();
  375.     let size = 0;
  377.     for (const op of this.code)
  378.       size += op.getSize();
  380.     const bw = bio.write(size);
  382.     for (const op of this.code)
  383.       op.toWriter(bw);
  385.     this.raw = bw.render();
  387.     return this;
  388.   }
  390.   /**
  391.    * Write the script to a buffer writer.
  392.    * @param {BufferWriter} bw
  393.    */
  395.   toWriter(bw) {
  396.     bw.writeVarBytes(this.raw);
  397.     return bw;
  398.   }
  400.   /**
  401.    * Encode the script to a Buffer. See {@link Script#encode}.
  402.    * @param {String} enc - Encoding, either `'hex'` or `null`.
  403.    * @returns {Buffer|String} Serialized script.
  404.    */
  406.   toRaw() {
  407.     return this.raw;
  408.   }
  410.   /**
  411.    * Convert script to a hex string.
  412.    * @returns {String}
  413.    */
  415.   toJSON() {
  416.     return this.toRaw().toString('hex');
  417.   }
  419.   /**
  420.    * Inject properties from json object.
  421.    * @private
  422.    * @param {String} json
  423.    */
  425.   fromJSON(json) {
  426.     assert(typeof json === 'string', 'Code must be a string.');
  427.     return this.fromRaw(Buffer.from(json, 'hex'));
  428.   }
  430.   /**
  431.    * Instantiate script from a hex string.
  432.    * @params {String} json
  433.    * @returns {Script}
  434.    */
  436.   static fromJSON(json) {
  437.     return new this().fromJSON(json);
  438.   }
  440.   /**
  441.    * Get the script's "subscript" starting at a separator.
  442.    * @param {Number} index - The last separator to sign/verify beyond.
  443.    * @returns {Script} Subscript.
  444.    */
  446.   getSubscript(index) {
  447.     if (index === 0)
  448.       return this.clone();
  450.     const script = new Script();
  452.     for (let i = index; i < this.code.length; i++) {
  453.       const op = this.code[i];
  455.       if (op.value === -1)
  456.         break;
  458.       script.code.push(op);
  459.     }
  461.     return script.compile();
  462.   }
  464.   /**
  465.    * Get the script's "subscript" starting at a separator.
  466.    * Remove all OP_CODESEPARATORs if present. This bizarre
  467.    * behavior is necessary for signing and verification when
  468.    * code separators are present.
  469.    * @returns {Script} Subscript.
  470.    */
  472.   removeSeparators() {
  473.     let found = false;
  475.     // Optimizing for the common case:
  476.     // Check for any separators first.
  477.     for (const op of this.code) {
  478.       if (op.value === -1)
  479.         break;
  481.       if (op.value === opcodes.OP_CODESEPARATOR) {
  482.         found = true;
  483.         break;
  484.       }
  485.     }
  487.     if (!found)
  488.       return this;
  490.     // Uncommon case: someone actually
  491.     // has a code separator. Go through
  492.     // and remove them all.
  493.     const script = new Script();
  495.     for (const op of this.code) {
  496.       if (op.value === -1)
  497.         break;
  499.       if (op.value !== opcodes.OP_CODESEPARATOR)
  500.         script.code.push(op);
  501.     }
  503.     return script.compile();
  504.   }
  506.   /**
  507.    * Execute and interpret the script.
  508.    * @param {Stack} stack - Script execution stack.
  509.    * @param {Number?} flags - Script standard flags.
  510.    * @param {TX?} tx - Transaction being verified.
  511.    * @param {Number?} index - Index of input being verified.
  512.    * @param {Amount?} value - Previous output value.
  513.    * @param {Number?} version - Signature hash version (0=legacy, 1=segwit).
  514.    * @throws {ScriptError} Will be thrown on VERIFY failures.
  515.    */
  517.   execute(stack, flags, tx, index, value, version) {
  518.     if (flags == null)
  519.       flags = Script.flags.STANDARD_VERIFY_FLAGS;
  521.     if (version == null)
  522.       version = 0;
  524.     if (this.raw.length > consensus.MAX_SCRIPT_SIZE)
  525.       throw new ScriptError('SCRIPT_SIZE');
  527.     const state = [];
  528.     const alt = [];
  530.     let lastSep = 0;
  531.     let opCount = 0;
  532.     let negate = 0;
  533.     let minimal = false;
  535.     if (flags & Script.flags.VERIFY_MINIMALDATA)
  536.       minimal = true;
  538.     for (let ip = 0; ip < this.code.length; ip++) {
  539.       const op = this.code[ip];
  541.       if (op.value === -1)
  542.         throw new ScriptError('BAD_OPCODE', op, ip);
  544.       if (op.data && op.data.length > consensus.MAX_SCRIPT_PUSH)
  545.         throw new ScriptError('PUSH_SIZE', op, ip);
  547.       if (op.value > opcodes.OP_16 && ++opCount > consensus.MAX_SCRIPT_OPS)
  548.         throw new ScriptError('OP_COUNT', op, ip);
  550.       if (op.isDisabled())
  551.         throw new ScriptError('DISABLED_OPCODE', op, ip);
  553.       if (op.value === opcodes.OP_CODESEPARATOR && version === 0 &&
  554.           (flags & Script.flags.VERIFY_CONST_SCRIPTCODE))
  555.         throw new ScriptError('OP_CODESEPARATOR', op, ip);
  557.       if (negate && !op.isBranch()) {
  558.         if (stack.length + alt.length > consensus.MAX_SCRIPT_STACK)
  559.           throw new ScriptError('STACK_SIZE', op, ip);
  560.         continue;
  561.       }
  563.       if (op.data) {
  564.         if (minimal && !op.isMinimal())
  565.           throw new ScriptError('MINIMALDATA', op, ip);
  567.         stack.push(op.data);
  569.         if (stack.length + alt.length > consensus.MAX_SCRIPT_STACK)
  570.           throw new ScriptError('STACK_SIZE', op, ip);
  572.         continue;
  573.       }
  575.       switch (op.value) {
  576.         case opcodes.OP_0: {
  577.           stack.pushInt(0);
  578.           break;
  579.         }
  580.         case opcodes.OP_1NEGATE: {
  581.           stack.pushInt(-1);
  582.           break;
  583.         }
  584.         case opcodes.OP_1:
  585.         case opcodes.OP_2:
  586.         case opcodes.OP_3:
  587.         case opcodes.OP_4:
  588.         case opcodes.OP_5:
  589.         case opcodes.OP_6:
  590.         case opcodes.OP_7:
  591.         case opcodes.OP_8:
  592.         case opcodes.OP_9:
  593.         case opcodes.OP_10:
  594.         case opcodes.OP_11:
  595.         case opcodes.OP_12:
  596.         case opcodes.OP_13:
  597.         case opcodes.OP_14:
  598.         case opcodes.OP_15:
  599.         case opcodes.OP_16: {
  600.           stack.pushInt(op.value - 0x50);
  601.           break;
  602.         }
  603.         case opcodes.OP_NOP: {
  604.           break;
  605.         }
  606.         case opcodes.OP_CHECKLOCKTIMEVERIFY: {
  607.           // OP_CHECKLOCKTIMEVERIFY = OP_NOP2
  608.           if (!(flags & Script.flags.VERIFY_CHECKLOCKTIMEVERIFY))
  609.             break;
  611.           if (!tx)
  612.             throw new ScriptError('UNKNOWN_ERROR', 'No TX passed in.');
  614.           if (stack.length === 0)
  615.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  617.           const num = stack.getNum(-1, minimal, 5);
  619.           if (num.isNeg())
  620.             throw new ScriptError('NEGATIVE_LOCKTIME', op, ip);
  622.           const locktime = num.toDouble();
  624.           if (!tx.verifyLocktime(index, locktime))
  625.             throw new ScriptError('UNSATISFIED_LOCKTIME', op, ip);
  627.           break;
  628.         }
  629.         case opcodes.OP_CHECKSEQUENCEVERIFY: {
  630.           // OP_CHECKSEQUENCEVERIFY = OP_NOP3
  631.           if (!(flags & Script.flags.VERIFY_CHECKSEQUENCEVERIFY))
  632.             break;
  634.           if (!tx)
  635.             throw new ScriptError('UNKNOWN_ERROR', 'No TX passed in.');
  637.           if (stack.length === 0)
  638.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  640.           const num = stack.getNum(-1, minimal, 5);
  642.           if (num.isNeg())
  643.             throw new ScriptError('NEGATIVE_LOCKTIME', op, ip);
  645.           const locktime = num.toDouble();
  647.           if (!tx.verifySequence(index, locktime))
  648.             throw new ScriptError('UNSATISFIED_LOCKTIME', op, ip);
  650.           break;
  651.         }
  652.         case opcodes.OP_NOP1:
  653.         case opcodes.OP_NOP4:
  654.         case opcodes.OP_NOP5:
  655.         case opcodes.OP_NOP6:
  656.         case opcodes.OP_NOP7:
  657.         case opcodes.OP_NOP8:
  658.         case opcodes.OP_NOP9:
  659.         case opcodes.OP_NOP10: {
  660.           if (flags & Script.flags.VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
  661.             throw new ScriptError('DISCOURAGE_UPGRADABLE_NOPS', op, ip);
  662.           break;
  663.         }
  664.         case opcodes.OP_IF:
  665.         case opcodes.OP_NOTIF: {
  666.           let val = false;
  668.           if (!negate) {
  669.             if (stack.length < 1)
  670.               throw new ScriptError('UNBALANCED_CONDITIONAL', op, ip);
  672.             if (version === 1 && (flags & Script.flags.VERIFY_MINIMALIF)) {
  673.               const item = stack.get(-1);
  675.               if (item.length > 1)
  676.                 throw new ScriptError('MINIMALIF');
  678.               if (item.length === 1 && item[0] !== 1)
  679.                 throw new ScriptError('MINIMALIF');
  680.             }
  682.             val = stack.getBool(-1);
  684.             if (op.value === opcodes.OP_NOTIF)
  685.               val = !val;
  687.             stack.pop();
  688.           }
  690.           state.push(val);
  692.           if (!val)
  693.             negate += 1;
  695.           break;
  696.         }
  697.         case opcodes.OP_ELSE: {
  698.           if (state.length === 0)
  699.             throw new ScriptError('UNBALANCED_CONDITIONAL', op, ip);
  701.           state[state.length - 1] = !state[state.length - 1];
  703.           if (!state[state.length - 1])
  704.             negate += 1;
  705.           else
  706.             negate -= 1;
  708.           break;
  709.         }
  710.         case opcodes.OP_ENDIF: {
  711.           if (state.length === 0)
  712.             throw new ScriptError('UNBALANCED_CONDITIONAL', op, ip);
  714.           if (!state.pop())
  715.             negate -= 1;
  717.           break;
  718.         }
  719.         case opcodes.OP_VERIFY: {
  720.           if (stack.length === 0)
  721.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  723.           if (!stack.getBool(-1))
  724.             throw new ScriptError('VERIFY', op, ip);
  726.           stack.pop();
  728.           break;
  729.         }
  730.         case opcodes.OP_RETURN: {
  731.           throw new ScriptError('OP_RETURN', op, ip);
  732.         }
  733.         case opcodes.OP_TOALTSTACK: {
  734.           if (stack.length === 0)
  735.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  737.           alt.push(stack.pop());
  738.           break;
  739.         }
  740.         case opcodes.OP_FROMALTSTACK: {
  741.           if (alt.length === 0)
  742.             throw new ScriptError('INVALID_ALTSTACK_OPERATION', op, ip);
  744.           stack.push(alt.pop());
  745.           break;
  746.         }
  747.         case opcodes.OP_2DROP: {
  748.           if (stack.length < 2)
  749.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  751.           stack.pop();
  752.           stack.pop();
  753.           break;
  754.         }
  755.         case opcodes.OP_2DUP: {
  756.           if (stack.length < 2)
  757.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  759.           const v1 = stack.get(-2);
  760.           const v2 = stack.get(-1);
  762.           stack.push(v1);
  763.           stack.push(v2);
  764.           break;
  765.         }
  766.         case opcodes.OP_3DUP: {
  767.           if (stack.length < 3)
  768.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  770.           const v1 = stack.get(-3);
  771.           const v2 = stack.get(-2);
  772.           const v3 = stack.get(-1);
  774.           stack.push(v1);
  775.           stack.push(v2);
  776.           stack.push(v3);
  777.           break;
  778.         }
  779.         case opcodes.OP_2OVER: {
  780.           if (stack.length < 4)
  781.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  783.           const v1 = stack.get(-4);
  784.           const v2 = stack.get(-3);
  786.           stack.push(v1);
  787.           stack.push(v2);
  788.           break;
  789.         }
  790.         case opcodes.OP_2ROT: {
  791.           if (stack.length < 6)
  792.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  794.           const v1 = stack.get(-6);
  795.           const v2 = stack.get(-5);
  797.           stack.erase(-6, -4);
  798.           stack.push(v1);
  799.           stack.push(v2);
  800.           break;
  801.         }
  802.         case opcodes.OP_2SWAP: {
  803.           if (stack.length < 4)
  804.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  806.           stack.swap(-4, -2);
  807.           stack.swap(-3, -1);
  808.           break;
  809.         }
  810.         case opcodes.OP_IFDUP: {
  811.           if (stack.length === 0)
  812.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  814.           if (stack.getBool(-1)) {
  815.             const val = stack.get(-1);
  816.             stack.push(val);
  817.           }
  819.           break;
  820.         }
  821.         case opcodes.OP_DEPTH: {
  822.           stack.pushInt(stack.length);
  823.           break;
  824.         }
  825.         case opcodes.OP_DROP: {
  826.           if (stack.length === 0)
  827.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  829.           stack.pop();
  830.           break;
  831.         }
  832.         case opcodes.OP_DUP: {
  833.           if (stack.length === 0)
  834.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  836.           stack.push(stack.get(-1));
  837.           break;
  838.         }
  839.         case opcodes.OP_NIP: {
  840.           if (stack.length < 2)
  841.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  843.           stack.remove(-2);
  844.           break;
  845.         }
  846.         case opcodes.OP_OVER: {
  847.           if (stack.length < 2)
  848.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  850.           stack.push(stack.get(-2));
  851.           break;
  852.         }
  853.         case opcodes.OP_PICK:
  854.         case opcodes.OP_ROLL: {
  855.           if (stack.length < 2)
  856.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  858.           const num = stack.getInt(-1, minimal, 4);
  859.           stack.pop();
  861.           if (num < 0 || num >= stack.length)
  862.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  864.           const val = stack.get(-num - 1);
  866.           if (op.value === opcodes.OP_ROLL)
  867.             stack.remove(-num - 1);
  869.           stack.push(val);
  870.           break;
  871.         }
  872.         case opcodes.OP_ROT: {
  873.           if (stack.length < 3)
  874.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  876.           stack.swap(-3, -2);
  877.           stack.swap(-2, -1);
  878.           break;
  879.         }
  880.         case opcodes.OP_SWAP: {
  881.           if (stack.length < 2)
  882.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  884.           stack.swap(-2, -1);
  885.           break;
  886.         }
  887.         case opcodes.OP_TUCK: {
  888.           if (stack.length < 2)
  889.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  891.           stack.insert(-2, stack.get(-1));
  892.           break;
  893.         }
  894.         case opcodes.OP_SIZE: {
  895.           if (stack.length < 1)
  896.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  898.           stack.pushInt(stack.get(-1).length);
  899.           break;
  900.         }
  901.         case opcodes.OP_EQUAL:
  902.         case opcodes.OP_EQUALVERIFY: {
  903.           if (stack.length < 2)
  904.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  906.           const v1 = stack.get(-2);
  907.           const v2 = stack.get(-1);
  909.           const res = v1.equals(v2);
  911.           stack.pop();
  912.           stack.pop();
  914.           stack.pushBool(res);
  916.           if (op.value === opcodes.OP_EQUALVERIFY) {
  917.             if (!res)
  918.               throw new ScriptError('EQUALVERIFY', op, ip);
  919.             stack.pop();
  920.           }
  922.           break;
  923.         }
  924.         case opcodes.OP_1ADD:
  925.         case opcodes.OP_1SUB:
  926.         case opcodes.OP_NEGATE:
  927.         case opcodes.OP_ABS:
  928.         case opcodes.OP_NOT:
  929.         case opcodes.OP_0NOTEQUAL: {
  930.           if (stack.length < 1)
  931.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  933.           let num = stack.getNum(-1, minimal, 4);
  934.           let cmp;
  936.           switch (op.value) {
  937.             case opcodes.OP_1ADD:
  938.               num.iaddn(1);
  939.               break;
  940.             case opcodes.OP_1SUB:
  941.               num.isubn(1);
  942.               break;
  943.             case opcodes.OP_NEGATE:
  944.               num.ineg();
  945.               break;
  946.             case opcodes.OP_ABS:
  947.               num.iabs();
  948.               break;
  949.             case opcodes.OP_NOT:
  950.               cmp = num.isZero();
  951.               num = ScriptNum.fromBool(cmp);
  952.               break;
  953.             case opcodes.OP_0NOTEQUAL:
  954.               cmp = !num.isZero();
  955.               num = ScriptNum.fromBool(cmp);
  956.               break;
  957.             default:
  958.               assert(false, 'Fatal script error.');
  959.               break;
  960.           }
  962.           stack.pop();
  963.           stack.pushNum(num);
  965.           break;
  966.         }
  967.         case opcodes.OP_ADD:
  968.         case opcodes.OP_SUB:
  969.         case opcodes.OP_BOOLAND:
  970.         case opcodes.OP_BOOLOR:
  971.         case opcodes.OP_NUMEQUAL:
  972.         case opcodes.OP_NUMEQUALVERIFY:
  973.         case opcodes.OP_NUMNOTEQUAL:
  974.         case opcodes.OP_LESSTHAN:
  975.         case opcodes.OP_GREATERTHAN:
  976.         case opcodes.OP_LESSTHANOREQUAL:
  977.         case opcodes.OP_GREATERTHANOREQUAL:
  978.         case opcodes.OP_MIN:
  979.         case opcodes.OP_MAX: {
  980.           if (stack.length < 2)
  981.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  983.           const n1 = stack.getNum(-2, minimal, 4);
  984.           const n2 = stack.getNum(-1, minimal, 4);
  985.           let num, cmp;
  987.           switch (op.value) {
  988.             case opcodes.OP_ADD:
  989.               num = n1.iadd(n2);
  990.               break;
  991.             case opcodes.OP_SUB:
  992.               num = n1.isub(n2);
  993.               break;
  994.             case opcodes.OP_BOOLAND:
  995.               cmp = n1.toBool() && n2.toBool();
  996.               num = ScriptNum.fromBool(cmp);
  997.               break;
  998.             case opcodes.OP_BOOLOR:
  999.               cmp = n1.toBool() || n2.toBool();
  1000.               num = ScriptNum.fromBool(cmp);
  1001.               break;
  1002.             case opcodes.OP_NUMEQUAL:
  1003.               cmp = n1.eq(n2);
  1004.               num = ScriptNum.fromBool(cmp);
  1005.               break;
  1006.             case opcodes.OP_NUMEQUALVERIFY:
  1007.               cmp = n1.eq(n2);
  1008.               num = ScriptNum.fromBool(cmp);
  1009.               break;
  1010.             case opcodes.OP_NUMNOTEQUAL:
  1011.               cmp = !n1.eq(n2);
  1012.               num = ScriptNum.fromBool(cmp);
  1013.               break;
  1014.             case opcodes.OP_LESSTHAN:
  1015.               cmp = n1.lt(n2);
  1016.               num = ScriptNum.fromBool(cmp);
  1017.               break;
  1018.             case opcodes.OP_GREATERTHAN:
  1019.               cmp = n1.gt(n2);
  1020.               num = ScriptNum.fromBool(cmp);
  1021.               break;
  1022.             case opcodes.OP_LESSTHANOREQUAL:
  1023.               cmp = n1.lte(n2);
  1024.               num = ScriptNum.fromBool(cmp);
  1025.               break;
  1026.             case opcodes.OP_GREATERTHANOREQUAL:
  1027.               cmp = n1.gte(n2);
  1028.               num = ScriptNum.fromBool(cmp);
  1029.               break;
  1030.             case opcodes.OP_MIN:
  1031.               num = ScriptNum.min(n1, n2);
  1032.               break;
  1033.             case opcodes.OP_MAX:
  1034.               num = ScriptNum.max(n1, n2);
  1035.               break;
  1036.             default:
  1037.               assert(false, 'Fatal script error.');
  1038.               break;
  1039.           }
  1041.           stack.pop();
  1042.           stack.pop();
  1043.           stack.pushNum(num);
  1045.           if (op.value === opcodes.OP_NUMEQUALVERIFY) {
  1046.             if (!stack.getBool(-1))
  1047.               throw new ScriptError('NUMEQUALVERIFY', op, ip);
  1048.             stack.pop();
  1049.           }
  1051.           break;
  1052.         }
  1053.         case opcodes.OP_WITHIN: {
  1054.           if (stack.length < 3)
  1055.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1057.           const n1 = stack.getNum(-3, minimal, 4);
  1058.           const n2 = stack.getNum(-2, minimal, 4);
  1059.           const n3 = stack.getNum(-1, minimal, 4);
  1061.           const val = n2.lte(n1) && n1.lt(n3);
  1063.           stack.pop();
  1064.           stack.pop();
  1065.           stack.pop();
  1067.           stack.pushBool(val);
  1068.           break;
  1069.         }
  1070.         case opcodes.OP_RIPEMD160: {
  1071.           if (stack.length === 0)
  1072.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1074.           stack.push(ripemd160.digest(stack.pop()));
  1075.           break;
  1076.         }
  1077.         case opcodes.OP_SHA1: {
  1078.           if (stack.length === 0)
  1079.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1081.           stack.push(sha1.digest(stack.pop()));
  1082.           break;
  1083.         }
  1084.         case opcodes.OP_SHA256: {
  1085.           if (stack.length === 0)
  1086.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1088.           stack.push(sha256.digest(stack.pop()));
  1089.           break;
  1090.         }
  1091.         case opcodes.OP_HASH160: {
  1092.           if (stack.length === 0)
  1093.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1095.           stack.push(hash160.digest(stack.pop()));
  1096.           break;
  1097.         }
  1098.         case opcodes.OP_HASH256: {
  1099.           if (stack.length === 0)
  1100.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1102.           stack.push(hash256.digest(stack.pop()));
  1103.           break;
  1104.         }
  1105.         case opcodes.OP_CODESEPARATOR: {
  1106.           lastSep = ip + 1;
  1107.           break;
  1108.         }
  1109.         case opcodes.OP_CHECKSIG:
  1110.         case opcodes.OP_CHECKSIGVERIFY: {
  1111.           if (!tx)
  1112.             throw new ScriptError('UNKNOWN_ERROR', 'No TX passed in.');
  1114.           if (stack.length < 2)
  1115.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1117.           const sig = stack.get(-2);
  1118.           const key = stack.get(-1);
  1120.           const subscript = this.getSubscript(lastSep);
  1122.           if (version === 0) {
  1123.             const found = subscript.findAndDelete(sig);
  1124.             if (found > 0 && (flags & Script.flags.VERIFY_CONST_SCRIPTCODE))
  1125.               throw new ScriptError('SIG_FINDANDDELETE', op, ip);
  1126.           }
  1128.           validateSignature(sig, flags);
  1129.           validateKey(key, flags, version);
  1131.           let res = false;
  1133.           if (sig.length > 0) {
  1134.             const type = sig[sig.length - 1];
  1135.             const hash = tx.signatureHash(
  1136.               index,
  1137.               subscript,
  1138.               value,
  1139.               type,
  1140.               version
  1141.             );
  1142.             res = checksig(hash, sig, key);
  1143.           }
  1145.           if (!res && (flags & Script.flags.VERIFY_NULLFAIL)) {
  1146.             if (sig.length !== 0)
  1147.               throw new ScriptError('NULLFAIL', op, ip);
  1148.           }
  1150.           stack.pop();
  1151.           stack.pop();
  1153.           stack.pushBool(res);
  1155.           if (op.value === opcodes.OP_CHECKSIGVERIFY) {
  1156.             if (!res)
  1157.               throw new ScriptError('CHECKSIGVERIFY', op, ip);
  1158.             stack.pop();
  1159.           }
  1161.           break;
  1162.         }
  1163.         case opcodes.OP_CHECKMULTISIG:
  1164.         case opcodes.OP_CHECKMULTISIGVERIFY: {
  1165.           if (!tx)
  1166.             throw new ScriptError('UNKNOWN_ERROR', 'No TX passed in.');
  1168.           let i = 1;
  1169.           if (stack.length < i)
  1170.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1172.           let n = stack.getInt(-i, minimal, 4);
  1173.           let okey = n + 2;
  1174.           let ikey, isig;
  1176.           if (n < 0 || n > consensus.MAX_MULTISIG_PUBKEYS)
  1177.             throw new ScriptError('PUBKEY_COUNT', op, ip);
  1179.           opCount += n;
  1181.           if (opCount > consensus.MAX_SCRIPT_OPS)
  1182.             throw new ScriptError('OP_COUNT', op, ip);
  1184.           i += 1;
  1185.           ikey = i;
  1186.           i += n;
  1188.           if (stack.length < i)
  1189.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1191.           let m = stack.getInt(-i, minimal, 4);
  1193.           if (m < 0 || m > n)
  1194.             throw new ScriptError('SIG_COUNT', op, ip);
  1196.           i += 1;
  1197.           isig = i;
  1198.           i += m;
  1200.           if (stack.length < i)
  1201.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1203.           const subscript = this.getSubscript(lastSep);
  1205.           for (let j = 0; j < m; j++) {
  1206.             const sig = stack.get(-isig - j);
  1207.             if (version === 0) {
  1208.               const found = subscript.findAndDelete(sig);
  1209.               if (found > 0 && (flags & Script.flags.VERIFY_CONST_SCRIPTCODE))
  1210.                 throw new ScriptError('SIG_FINDANDDELETE', op, ip);
  1211.             }
  1212.           }
  1214.           let res = true;
  1215.           while (res && m > 0) {
  1216.             const sig = stack.get(-isig);
  1217.             const key = stack.get(-ikey);
  1219.             validateSignature(sig, flags);
  1220.             validateKey(key, flags, version);
  1222.             if (sig.length > 0) {
  1223.               const type = sig[sig.length - 1];
  1224.               const hash = tx.signatureHash(
  1225.                 index,
  1226.                 subscript,
  1227.                 value,
  1228.                 type,
  1229.                 version
  1230.               );
  1232.               if (checksig(hash, sig, key)) {
  1233.                 isig += 1;
  1234.                 m -= 1;
  1235.               }
  1236.             }
  1238.             ikey += 1;
  1239.             n -= 1;
  1241.             if (m > n)
  1242.               res = false;
  1243.           }
  1245.           while (i > 1) {
  1246.             if (!res && (flags & Script.flags.VERIFY_NULLFAIL)) {
  1247.               if (okey === 0 && stack.get(-1).length !== 0)
  1248.                 throw new ScriptError('NULLFAIL', op, ip);
  1249.             }
  1251.             if (okey > 0)
  1252.               okey -= 1;
  1254.             stack.pop();
  1256.             i -= 1;
  1257.           }
  1259.           if (stack.length < 1)
  1260.             throw new ScriptError('INVALID_STACK_OPERATION', op, ip);
  1262.           if (flags & Script.flags.VERIFY_NULLDUMMY) {
  1263.             if (stack.get(-1).length !== 0)
  1264.               throw new ScriptError('SIG_NULLDUMMY', op, ip);
  1265.           }
  1267.           stack.pop();
  1269.           stack.pushBool(res);
  1271.           if (op.value === opcodes.OP_CHECKMULTISIGVERIFY) {
  1272.             if (!res)
  1273.               throw new ScriptError('CHECKMULTISIGVERIFY', op, ip);
  1274.             stack.pop();
  1275.           }
  1277.           break;
  1278.         }
  1279.         default: {
  1280.           throw new ScriptError('BAD_OPCODE', op, ip);
  1281.         }
  1282.       }
  1284.       if (stack.length + alt.length > consensus.MAX_SCRIPT_STACK)
  1285.         throw new ScriptError('STACK_SIZE', op, ip);
  1286.     }
  1288.     if (state.length !== 0)
  1289.       throw new ScriptError('UNBALANCED_CONDITIONAL');
  1290.   }
  1292.   /**
  1293.    * Remove all matched data elements from
  1294.    * a script's code (used to remove signatures
  1295.    * before verification). Note that this
  1296.    * compares and removes data on the _byte level_.
  1297.    * It also reserializes the data to a single
  1298.    * script with minimaldata encoding beforehand.
  1299.    * A signature will _not_ be removed if it is
  1300.    * not minimaldata.
  1301.    * @see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2014-November/006878.html
  1302.    * @see https://test.webbtc.com/tx/19aa42fee0fa57c45d3b16488198b27caaacc4ff5794510d0c17f173f05587ff
  1303.    * @param {Buffer} data - Data element to match against.
  1304.    * @returns {Number} Total.
  1305.    */
  1307.   findAndDelete(data) {
  1308.     const target = Opcode.fromPush(data);
  1310.     if (this.raw.length < target.getSize())
  1311.       return 0;
  1313.     let found = false;
  1315.     for (const op of this.code) {
  1316.       if (op.value === -1)
  1317.         break;
  1319.       if (op.equals(target)) {
  1320.         found = true;
  1321.         break;
  1322.       }
  1323.     }
  1325.     if (!found)
  1326.       return 0;
  1328.     const code = [];
  1330.     let total = 0;
  1332.     for (const op of this.code) {
  1333.       if (op.value === -1)
  1334.         break;
  1336.       if (op.equals(target)) {
  1337.         total += 1;
  1338.         continue;
  1339.       }
  1341.       code.push(op);
  1342.     }
  1344.     this.code = code;
  1345.     this.compile();
  1347.     return total;
  1348.   }
  1350.   /**
  1351.    * Find a data element in a script.
  1352.    * @param {Buffer} data - Data element to match against.
  1353.    * @returns {Number} Index (`-1` if not present).
  1354.    */
  1356.   indexOf(data) {
  1357.     for (let i = 0; i < this.code.length; i++) {
  1358.       const op = this.code[i];
  1360.       if (op.value === -1)
  1361.         break;
  1363.       if (!op.data)
  1364.         continue;
  1366.       if (op.data.equals(data))
  1367.         return i;
  1368.     }
  1370.     return -1;
  1371.   }
  1373.   /**
  1374.    * Test a script to see if it is likely
  1375.    * to be script code (no weird opcodes).
  1376.    * @returns {Boolean}
  1377.    */
  1379.   isCode() {
  1380.     for (const op of this.code) {
  1381.       if (op.value === -1)
  1382.         return false;
  1384.       if (op.isDisabled())
  1385.         return false;
  1387.       switch (op.value) {
  1388.         case opcodes.OP_RESERVED:
  1389.         case opcodes.OP_NOP:
  1390.         case opcodes.OP_VER:
  1391.         case opcodes.OP_VERIF:
  1392.         case opcodes.OP_VERNOTIF:
  1393.         case opcodes.OP_RESERVED1:
  1394.         case opcodes.OP_RESERVED2:
  1395.         case opcodes.OP_NOP1:
  1396.           return false;
  1397.       }
  1399.       if (op.value > opcodes.OP_CHECKSEQUENCEVERIFY)
  1400.         return false;
  1401.     }
  1403.     return true;
  1404.   }
  1406.   /**
  1407.    * Inject properties from a pay-to-pubkey script.
  1408.    * @private
  1409.    * @param {Buffer} key
  1410.    */
  1412.   fromPubkey(key) {
  1413.     assert(Buffer.isBuffer(key) && (key.length === 33 || key.length === 65));
  1415.     this.raw = Buffer.allocUnsafe(1 + key.length + 1);
  1416.     this.raw[0] = key.length;
  1417.     key.copy(this.raw, 1);
  1418.     this.raw[1 + key.length] = opcodes.OP_CHECKSIG;
  1420.     key = this.raw.slice(1, 1 + key.length);
  1422.     this.code.length = 0;
  1423.     this.code.push(Opcode.fromPush(key));
  1424.     this.code.push(Opcode.fromOp(opcodes.OP_CHECKSIG));
  1426.     return this;
  1427.   }
  1429.   /**
  1430.    * Create a pay-to-pubkey script.
  1431.    * @param {Buffer} key
  1432.    * @returns {Script}
  1433.    */
  1435.   static fromPubkey(key) {
  1436.     return new this().fromPubkey(key);
  1437.   }
  1439.   /**
  1440.    * Inject properties from a pay-to-pubkeyhash script.
  1441.    * @private
  1442.    * @param {Buffer} hash
  1443.    */
  1445.   fromPubkeyhash(hash) {
  1446.     assert(Buffer.isBuffer(hash) && hash.length === 20);
  1448.     this.raw = Buffer.allocUnsafe(25);
  1449.     this.raw[0] = opcodes.OP_DUP;
  1450.     this.raw[1] = opcodes.OP_HASH160;
  1451.     this.raw[2] = 0x14;
  1452.     hash.copy(this.raw, 3);
  1453.     this.raw[23] = opcodes.OP_EQUALVERIFY;
  1454.     this.raw[24] = opcodes.OP_CHECKSIG;
  1456.     hash = this.raw.slice(3, 23);
  1458.     this.code.length = 0;
  1459.     this.code.push(Opcode.fromOp(opcodes.OP_DUP));
  1460.     this.code.push(Opcode.fromOp(opcodes.OP_HASH160));
  1461.     this.code.push(Opcode.fromPush(hash));
  1462.     this.code.push(Opcode.fromOp(opcodes.OP_EQUALVERIFY));
  1463.     this.code.push(Opcode.fromOp(opcodes.OP_CHECKSIG));
  1465.     return this;
  1466.   }
  1468.   /**
  1469.    * Create a pay-to-pubkeyhash script.
  1470.    * @param {Buffer} hash
  1471.    * @returns {Script}
  1472.    */
  1474.   static fromPubkeyhash(hash) {
  1475.     return new this().fromPubkeyhash(hash);
  1476.   }
  1478.   /**
  1479.    * Inject properties from pay-to-multisig script.
  1480.    * @private
  1481.    * @param {Number} m
  1482.    * @param {Number} n
  1483.    * @param {Buffer[]} keys
  1484.    */
  1486.   fromMultisig(m, n, keys) {
  1487.     assert((m & 0xff) === m && (n & 0xff) === n);
  1488.     assert(Array.isArray(keys));
  1489.     assert(keys.length === n, '`n` keys are required for multisig.');
  1490.     assert(m >= 1 && m <= n);
  1491.     assert(n >= 1 && n <= 15);
  1493.     this.clear();
  1495.     this.pushSmall(m);
  1497.     for (const key of sortKeys(keys))
  1498.       this.pushData(key);
  1500.     this.pushSmall(n);
  1501.     this.pushOp(opcodes.OP_CHECKMULTISIG);
  1503.     return this.compile();
  1504.   }
  1506.   /**
  1507.    * Create a pay-to-multisig script.
  1508.    * @param {Number} m
  1509.    * @param {Number} n
  1510.    * @param {Buffer[]} keys
  1511.    * @returns {Script}
  1512.    */
  1514.   static fromMultisig(m, n, keys) {
  1515.     return new this().fromMultisig(m, n, keys);
  1516.   }
  1518.   /**
  1519.    * Inject properties from a pay-to-scripthash script.
  1520.    * @private
  1521.    * @param {Buffer} hash
  1522.    */
  1524.   fromScripthash(hash) {
  1525.     assert(Buffer.isBuffer(hash) && hash.length === 20);
  1527.     this.raw = Buffer.allocUnsafe(23);
  1528.     this.raw[0] = opcodes.OP_HASH160;
  1529.     this.raw[1] = 0x14;
  1530.     hash.copy(this.raw, 2);
  1531.     this.raw[22] = opcodes.OP_EQUAL;
  1533.     hash = this.raw.slice(2, 22);
  1535.     this.code.length = 0;
  1536.     this.code.push(Opcode.fromOp(opcodes.OP_HASH160));
  1537.     this.code.push(Opcode.fromPush(hash));
  1538.     this.code.push(Opcode.fromOp(opcodes.OP_EQUAL));
  1540.     return this;
  1541.   }
  1543.   /**
  1544.    * Create a pay-to-scripthash script.
  1545.    * @param {Buffer} hash
  1546.    * @returns {Script}
  1547.    */
  1549.   static fromScripthash(hash) {
  1550.     return new this().fromScripthash(hash);
  1551.   }
  1553.   /**
  1554.    * Inject properties from a nulldata/opreturn script.
  1555.    * @private
  1556.    * @param {Buffer} flags
  1557.    */
  1559.   fromNulldata(flags) {
  1560.     assert(Buffer.isBuffer(flags));
  1561.     assert(flags.length <= policy.MAX_OP_RETURN, 'Nulldata too large.');
  1563.     this.clear();
  1564.     this.pushOp(opcodes.OP_RETURN);
  1565.     this.pushData(flags);
  1567.     return this.compile();
  1568.   }
  1570.   /**
  1571.    * Create a nulldata/opreturn script.
  1572.    * @param {Buffer} flags
  1573.    * @returns {Script}
  1574.    */
  1576.   static fromNulldata(flags) {
  1577.     return new this().fromNulldata(flags);
  1578.   }
  1580.   /**
  1581.    * Inject properties from a witness program.
  1582.    * @private
  1583.    * @param {Number} version
  1584.    * @param {Buffer} data
  1585.    */
  1587.   fromProgram(version, data) {
  1588.     assert((version & 0xff) === version && version >= 0 && version <= 16);
  1589.     assert(Buffer.isBuffer(data) && data.length >= 2 && data.length <= 40);
  1591.     this.raw = Buffer.allocUnsafe(2 + data.length);
  1592.     this.raw[0] = version === 0 ? 0 : version + 0x50;
  1593.     this.raw[1] = data.length;
  1594.     data.copy(this.raw, 2);
  1596.     data = this.raw.slice(2, 2 + data.length);
  1598.     this.code.length = 0;
  1599.     this.code.push(Opcode.fromSmall(version));
  1600.     this.code.push(Opcode.fromPush(data));
  1602.     return this;
  1603.   }
  1605.   /**
  1606.    * Create a witness program.
  1607.    * @param {Number} version
  1608.    * @param {Buffer} data
  1609.    * @returns {Script}
  1610.    */
  1612.   static fromProgram(version, data) {
  1613.     return new this().fromProgram(version, data);
  1614.   }
  1616.   /**
  1617.    * Inject properties from an address.
  1618.    * @private
  1619.    * @param {Address|AddressString} address
  1620.    */
  1622.   fromAddress(address) {
  1623.     if (typeof address === 'string')
  1624.       address = Address.fromString(address);
  1626.     assert(address instanceof Address, 'Not an address.');
  1628.     if (address.isPubkeyhash())
  1629.       return this.fromPubkeyhash(address.hash);
  1631.     if (address.isScripthash())
  1632.       return this.fromScripthash(address.hash);
  1634.     if (address.isProgram())
  1635.       return this.fromProgram(address.version, address.hash);
  1637.     throw new Error('Unknown address type.');
  1638.   }
  1640.   /**
  1641.    * Create an output script from an address.
  1642.    * @param {Address|AddressString} address
  1643.    * @returns {Script}
  1644.    */
  1646.   static fromAddress(address) {
  1647.     return new this().fromAddress(address);
  1648.   }
  1650.   /**
  1651.    * Inject properties from a witness block commitment.
  1652.    * @private
  1653.    * @param {Buffer} hash
  1654.    * @param {String|Buffer} flags
  1655.    */
  1657.   fromCommitment(hash, flags) {
  1658.     const bw = bio.write(36);
  1660.     bw.writeU32BE(0xaa21a9ed);
  1661.     bw.writeHash(hash);
  1663.     this.clear();
  1664.     this.pushOp(opcodes.OP_RETURN);
  1665.     this.pushData(bw.render());
  1667.     if (flags)
  1668.       this.pushData(flags);
  1670.     return this.compile();
  1671.   }
  1673.   /**
  1674.    * Create a witness block commitment.
  1675.    * @param {Buffer} hash
  1676.    * @param {String|Buffer} flags
  1677.    * @returns {Script}
  1678.    */
  1680.   static fromCommitment(hash, flags) {
  1681.     return new this().fromCommitment(hash, flags);
  1682.   }
  1684.   /**
  1685.    * Grab and deserialize the redeem script.
  1686.    * @returns {Script|null} Redeem script.
  1687.    */
  1689.   getRedeem() {
  1690.     let data = null;
  1692.     for (const op of this.code) {
  1693.       if (op.value === -1)
  1694.         return null;
  1696.       if (op.value > opcodes.OP_16)
  1697.         return null;
  1699.       data = op.data;
  1700.     }
  1702.     if (!data)
  1703.       return null;
  1705.     return Script.fromRaw(data);
  1706.   }
  1708.   /**
  1709.    * Get the standard script type.
  1710.    * @returns {ScriptType}
  1711.    */
  1713.   getType() {
  1714.     if (this.isPubkey())
  1715.       return scriptTypes.PUBKEY;
  1717.     if (this.isPubkeyhash())
  1718.       return scriptTypes.PUBKEYHASH;
  1720.     if (this.isScripthash())
  1721.       return scriptTypes.SCRIPTHASH;
  1723.     if (this.isWitnessPubkeyhash())
  1724.       return scriptTypes.WITNESSPUBKEYHASH;
  1726.     if (this.isWitnessScripthash())
  1727.       return scriptTypes.WITNESSSCRIPTHASH;
  1729.     if (this.isMultisig())
  1730.       return scriptTypes.MULTISIG;
  1732.     if (this.isNulldata())
  1733.       return scriptTypes.NULLDATA;
  1735.     return scriptTypes.NONSTANDARD;
  1736.   }
  1738.   /**
  1739.    * Test whether a script is of an unknown/non-standard type.
  1740.    * @returns {Boolean}
  1741.    */
  1743.   isUnknown() {
  1744.     return this.getType() === scriptTypes.NONSTANDARD;
  1745.   }
  1747.   /**
  1748.    * Test whether the script is standard by policy standards.
  1749.    * @returns {Boolean}
  1750.    */
  1752.   isStandard() {
  1753.     const [m, n] = this.getMultisig();
  1755.     if (m !== -1) {
  1756.       if (n < 1 || n > 3)
  1757.         return false;
  1759.       if (m < 1 || m > n)
  1760.         return false;
  1762.       return true;
  1763.     }
  1765.     if (this.isNulldata())
  1766.       return this.raw.length <= policy.MAX_OP_RETURN_BYTES;
  1768.     return this.getType() !== scriptTypes.NONSTANDARD;
  1769.   }
  1771.   /**
  1772.    * Calculate the size of the script
  1773.    * excluding the varint size bytes.
  1774.    * @returns {Number}
  1775.    */
  1777.   getSize() {
  1778.     return this.raw.length;
  1779.   }
  1781.   /**
  1782.    * Calculate the size of the script
  1783.    * including the varint size bytes.
  1784.    * @returns {Number}
  1785.    */
  1787.   getVarSize() {
  1788.     return encoding.sizeVarBytes(this.raw);
  1789.   }
  1791.   /**
  1792.    * "Guess" the address of the input script.
  1793.    * This method is not 100% reliable.
  1794.    * @returns {Address|null}
  1795.    */
  1797.   getInputAddress() {
  1798.     return Address.fromInputScript(this);
  1799.   }
  1801.   /**
  1802.    * Get the address of the script if present. Note that
  1803.    * pubkey and multisig scripts will be treated as though
  1804.    * they are pubkeyhash and scripthashes respectively.
  1805.    * @returns {Address|null}
  1806.    */
  1808.   getAddress() {
  1809.     return Address.fromScript(this);
  1810.   }
  1812.   /**
  1813.    * Get the hash160 of the raw script.
  1814.    * @param {String?} enc
  1815.    * @returns {Hash}
  1816.    */
  1818.   hash160(enc) {
  1819.     let hash = hash160.digest(this.toRaw());
  1820.     if (enc === 'hex')
  1821.       hash = hash.toString('hex');
  1822.     return hash;
  1823.   }
  1825.   /**
  1826.    * Get the sha256 of the raw script.
  1827.    * @param {String?} enc
  1828.    * @returns {Hash}
  1829.    */
  1831.   sha256(enc) {
  1832.     let hash = sha256.digest(this.toRaw());
  1833.     if (enc === 'hex')
  1834.       hash = hash.toString('hex');
  1835.     return hash;
  1836.   }
  1838.   /**
  1839.    * Test whether the output script is pay-to-pubkey.
  1840.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1841.    * @returns {Boolean}
  1842.    */
  1844.   isPubkey(minimal) {
  1845.     if (minimal) {
  1846.       return this.raw.length >= 35
  1847.         && (this.raw[0] === 33 || this.raw[0] === 65)
  1848.         && this.raw[0] + 2 === this.raw.length
  1849.         && this.raw[this.raw.length - 1] === opcodes.OP_CHECKSIG;
  1850.     }
  1852.     if (this.code.length !== 2)
  1853.       return false;
  1855.     const size = this.getLength(0);
  1857.     return (size === 33 || size === 65)
  1858.       && this.getOp(1) === opcodes.OP_CHECKSIG;
  1859.   }
  1861.   /**
  1862.    * Get P2PK key if present.
  1863.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1864.    * @returns {Buffer|null}
  1865.    */
  1867.   getPubkey(minimal) {
  1868.     if (!this.isPubkey(minimal))
  1869.       return null;
  1871.     if (minimal)
  1872.       return this.raw.slice(1, 1 + this.raw[0]);
  1874.     return this.getData(0);
  1875.   }
  1877.   /**
  1878.    * Test whether the output script is pay-to-pubkeyhash.
  1879.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1880.    * @returns {Boolean}
  1881.    */
  1883.   isPubkeyhash(minimal) {
  1884.     if (minimal || this.raw.length === 25) {
  1885.       return this.raw.length === 25
  1886.         && this.raw[0] === opcodes.OP_DUP
  1887.         && this.raw[1] === opcodes.OP_HASH160
  1888.         && this.raw[2] === 0x14
  1889.         && this.raw[23] === opcodes.OP_EQUALVERIFY
  1890.         && this.raw[24] === opcodes.OP_CHECKSIG;
  1891.     }
  1893.     if (this.code.length !== 5)
  1894.       return false;
  1896.     return this.getOp(0) === opcodes.OP_DUP
  1897.       && this.getOp(1) === opcodes.OP_HASH160
  1898.       && this.getLength(2) === 20
  1899.       && this.getOp(3) === opcodes.OP_EQUALVERIFY
  1900.       && this.getOp(4) === opcodes.OP_CHECKSIG;
  1901.   }
  1903.   /**
  1904.    * Get P2PKH hash if present.
  1905.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1906.    * @returns {Buffer|null}
  1907.    */
  1909.   getPubkeyhash(minimal) {
  1910.     if (!this.isPubkeyhash(minimal))
  1911.       return null;
  1913.     if (minimal)
  1914.       return this.raw.slice(3, 23);
  1916.     return this.getData(2);
  1917.   }
  1919.   /**
  1920.    * Test whether the output script is pay-to-multisig.
  1921.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1922.    * @returns {Boolean}
  1923.    */
  1925.   isMultisig(minimal) {
  1926.     if (this.code.length < 4 || this.code.length > 19)
  1927.       return false;
  1929.     if (this.getOp(-1) !== opcodes.OP_CHECKMULTISIG)
  1930.       return false;
  1932.     const m = this.getSmall(0);
  1934.     if (m < 1)
  1935.       return false;
  1937.     const n = this.getSmall(-2);
  1939.     if (n < 1 || m > n)
  1940.       return false;
  1942.     if (this.code.length !== n + 3)
  1943.       return false;
  1945.     for (let i = 1; i < n + 1; i++) {
  1946.       const op = this.code[i];
  1947.       const size = op.toLength();
  1949.       if (size !== 33 && size !== 65)
  1950.         return false;
  1952.       if (minimal && !op.isMinimal())
  1953.         return false;
  1954.     }
  1956.     return true;
  1957.   }
  1959.   /**
  1960.    * Get multisig m and n values if present.
  1961.    * @param {Boolean} [minimal=false] - Minimaldata only.
  1962.    * @returns {Array} [m, n]
  1963.    */
  1965.   getMultisig(minimal) {
  1966.     if (!this.isMultisig(minimal))
  1967.       return [-1, -1];
  1969.     return [this.getSmall(0), this.getSmall(-2)];
  1970.   }
  1972.   /**
  1973.    * Test whether the output script is pay-to-scripthash. Note that
  1974.    * bitcoin itself requires scripthashes to be in strict minimaldata
  1975.    * encoding. Using `OP_HASH160 OP_PUSHDATA1 [hash] OP_EQUAL` will
  1976.    * _not_ be recognized as a scripthash.
  1977.    * @returns {Boolean}
  1978.    */
  1980.   isScripthash() {
  1981.     return this.raw.length === 23
  1982.       && this.raw[0] === opcodes.OP_HASH160
  1983.       && this.raw[1] === 0x14
  1984.       && this.raw[22] === opcodes.OP_EQUAL;
  1985.   }
  1987.   /**
  1988.    * Get P2SH hash if present.
  1989.    * @returns {Buffer|null}
  1990.    */
  1992.   getScripthash() {
  1993.     if (!this.isScripthash())
  1994.       return null;
  1996.     return this.getData(1);
  1997.   }
  1999.   /**
  2000.    * Test whether the output script is nulldata/opreturn.
  2001.    * @param {Boolean} [minimal=false] - Minimaldata only.
  2002.    * @returns {Boolean}
  2003.    */
  2005.   isNulldata(minimal) {
  2006.     if (this.code.length === 0)
  2007.       return false;
  2009.     if (this.getOp(0) !== opcodes.OP_RETURN)
  2010.       return false;
  2012.     if (this.code.length === 1)
  2013.       return true;
  2015.     if (minimal) {
  2016.       if (this.raw.length > policy.MAX_OP_RETURN_BYTES)
  2017.         return false;
  2018.     }
  2020.     for (let i = 1; i < this.code.length; i++) {
  2021.       const op = this.code[i];
  2023.       if (op.value === -1)
  2024.         return false;
  2026.       if (op.value > opcodes.OP_16)
  2027.         return false;
  2029.       if (minimal && !op.isMinimal())
  2030.         return false;
  2031.     }
  2033.     return true;
  2034.   }
  2036.   /**
  2037.    * Get OP_RETURN data if present.
  2038.    * @param {Boolean} [minimal=false] - Minimaldata only.
  2039.    * @returns {Buffer|null}
  2040.    */
  2042.   getNulldata(minimal) {
  2043.     if (!this.isNulldata(minimal))
  2044.       return null;
  2046.     for (let i = 1; i < this.code.length; i++) {
  2047.       const op = this.code[i];
  2048.       const data = op.toPush();
  2049.       if (data)
  2050.         return data;
  2051.     }
  2053.     return EMPTY_BUFFER;
  2054.   }
  2056.   /**
  2057.    * Test whether the output script is a segregated witness
  2058.    * commitment.
  2059.    * @returns {Boolean}
  2060.    */
  2062.   isCommitment() {
  2063.     return this.raw.length >= 38
  2064.       && this.raw[0] === opcodes.OP_RETURN
  2065.       && this.raw[1] === 0x24
  2066.       && this.raw.readUInt32BE(2, true) === 0xaa21a9ed;
  2067.   }
  2069.   /**
  2070.    * Get the commitment hash if present.
  2071.    * @returns {Buffer|null}
  2072.    */
  2074.   getCommitment() {
  2075.     if (!this.isCommitment())
  2076.       return null;
  2078.     return this.raw.slice(6, 38);
  2079.   }
  2081.   /**
  2082.    * Test whether the output script is a witness program.
  2083.    * Note that this will return true even for malformed
  2084.    * witness v0 programs.
  2085.    * @return {Boolean}
  2086.    */
  2088.   isProgram() {
  2089.     if (this.raw.length < 4 || this.raw.length > 42)
  2090.       return false;
  2092.     if (this.raw[0] !== opcodes.OP_0
  2093.         && (this.raw[0] < opcodes.OP_1 || this.raw[0] > opcodes.OP_16)) {
  2094.       return false;
  2095.     }
  2097.     if (this.raw[1] + 2 !== this.raw.length)
  2098.       return false;
  2100.     return true;
  2101.   }
  2103.   /**
  2104.    * Get the witness program if present.
  2105.    * @returns {Program|null}
  2106.    */
  2108.   getProgram() {
  2109.     if (!this.isProgram())
  2110.       return null;
  2112.     const version = this.getSmall(0);
  2113.     const data = this.getData(1);
  2115.     return new Program(version, data);
  2116.   }
  2118.   /**
  2119.    * Get the script to the equivalent witness
  2120.    * program (mimics bitcoind's scriptForWitness).
  2121.    * @returns {Script|null}
  2122.    */
  2124.   forWitness() {
  2125.     if (this.isProgram())
  2126.       return this.clone();
  2128.     const pk = this.getPubkey();
  2129.     if (pk) {
  2130.       const hash = hash160.digest(pk);
  2131.       return Script.fromProgram(0, hash);
  2132.     }
  2134.     const pkh = this.getPubkeyhash();
  2135.     if (pkh)
  2136.       return Script.fromProgram(0, pkh);
  2138.     return Script.fromProgram(0, this.sha256());
  2139.   }
  2141.   /**
  2142.    * Test whether the output script is
  2143.    * a pay-to-witness-pubkeyhash program.
  2144.    * @returns {Boolean}
  2145.    */
  2147.   isWitnessPubkeyhash() {
  2148.     return this.raw.length === 22
  2149.       && this.raw[0] === opcodes.OP_0
  2150.       && this.raw[1] === 0x14;
  2151.   }
  2153.   /**
  2154.    * Get P2WPKH hash if present.
  2155.    * @returns {Buffer|null}
  2156.    */
  2158.   getWitnessPubkeyhash() {
  2159.     if (!this.isWitnessPubkeyhash())
  2160.       return null;
  2162.     return this.getData(1);
  2163.   }
  2165.   /**
  2166.    * Test whether the output script is
  2167.    * a pay-to-witness-scripthash program.
  2168.    * @returns {Boolean}
  2169.    */
  2171.   isWitnessScripthash() {
  2172.     return this.raw.length === 34
  2173.       && this.raw[0] === opcodes.OP_0
  2174.       && this.raw[1] === 0x20;
  2175.   }
  2177.   /**
  2178.    * Get P2WSH hash if present.
  2179.    * @returns {Buffer|null}
  2180.    */
  2182.   getWitnessScripthash() {
  2183.     if (!this.isWitnessScripthash())
  2184.       return null;
  2186.     return this.getData(1);
  2187.   }
  2189.   /**
  2190.    * Test whether the output script is unspendable.
  2191.    * @returns {Boolean}
  2192.    */
  2194.   isUnspendable() {
  2195.     if (this.raw.length > consensus.MAX_SCRIPT_SIZE)
  2196.       return true;
  2198.     return this.raw.length > 0 && this.raw[0] === opcodes.OP_RETURN;
  2199.   }
  2201.   /**
  2202.    * "Guess" the type of the input script.
  2203.    * This method is not 100% reliable.
  2204.    * @returns {ScriptType}
  2205.    */
  2207.   getInputType() {
  2208.     if (this.isPubkeyInput())
  2209.       return scriptTypes.PUBKEY;
  2211.     if (this.isPubkeyhashInput())
  2212.       return scriptTypes.PUBKEYHASH;
  2214.     if (this.isScripthashInput())
  2215.       return scriptTypes.SCRIPTHASH;
  2217.     if (this.isMultisigInput())
  2218.       return scriptTypes.MULTISIG;
  2220.     return scriptTypes.NONSTANDARD;
  2221.   }
  2223.   /**
  2224.    * "Guess" whether the input script is an unknown/non-standard type.
  2225.    * This method is not 100% reliable.
  2226.    * @returns {Boolean}
  2227.    */
  2229.   isUnknownInput() {
  2230.     return this.getInputType() === scriptTypes.NONSTANDARD;
  2231.   }
  2233.   /**
  2234.    * "Guess" whether the input script is pay-to-pubkey.
  2235.    * This method is not 100% reliable.
  2236.    * @returns {Boolean}
  2237.    */
  2239.   isPubkeyInput() {
  2240.     if (this.code.length !== 1)
  2241.       return false;
  2243.     const size = this.getLength(0);
  2245.     return size >= 9 && size <= 73;
  2246.   }
  2248.   /**
  2249.    * Get P2PK signature if present.
  2250.    * @returns {Buffer|null}
  2251.    */
  2253.   getPubkeyInput() {
  2254.     if (!this.isPubkeyInput())
  2255.       return null;
  2257.     return this.getData(0);
  2258.   }
  2260.   /**
  2261.    * "Guess" whether the input script is pay-to-pubkeyhash.
  2262.    * This method is not 100% reliable.
  2263.    * @returns {Boolean}
  2264.    */
  2266.   isPubkeyhashInput() {
  2267.     if (this.code.length !== 2)
  2268.       return false;
  2270.     const sig = this.getLength(0);
  2271.     const key = this.getLength(1);
  2273.     return sig >= 9 && sig <= 73
  2274.       && (key === 33 || key === 65);
  2275.   }
  2277.   /**
  2278.    * Get P2PKH signature and key if present.
  2279.    * @returns {Array} [sig, key]
  2280.    */
  2282.   getPubkeyhashInput() {
  2283.     if (!this.isPubkeyhashInput())
  2284.       return [null, null];
  2286.     return [this.getData(0), this.getData(1)];
  2287.   }
  2289.   /**
  2290.    * "Guess" whether the input script is pay-to-multisig.
  2291.    * This method is not 100% reliable.
  2292.    * @returns {Boolean}
  2293.    */
  2295.   isMultisigInput() {
  2296.     if (this.code.length < 2)
  2297.       return false;
  2299.     if (this.getOp(0) !== opcodes.OP_0)
  2300.       return false;
  2302.     if (this.getOp(1) > opcodes.OP_PUSHDATA4)
  2303.       return false;
  2305.     // We need to rule out scripthash
  2306.     // because it may look like multisig.
  2307.     if (this.isScripthashInput())
  2308.       return false;
  2310.     for (let i = 1; i < this.code.length; i++) {
  2311.       const size = this.getLength(i);
  2312.       if (size < 9 || size > 73)
  2313.         return false;
  2314.     }
  2316.     return true;
  2317.   }
  2319.   /**
  2320.    * Get multisig signatures if present.
  2321.    * @returns {Buffer[]|null}
  2322.    */
  2324.   getMultisigInput() {
  2325.     if (!this.isMultisigInput())
  2326.       return null;
  2328.     const sigs = [];
  2330.     for (let i = 1; i < this.code.length; i++)
  2331.       sigs.push(this.getData(i));
  2333.     return sigs;
  2334.   }
  2336.   /**
  2337.    * "Guess" whether the input script is pay-to-scripthash.
  2338.    * This method is not 100% reliable.
  2339.    * @returns {Boolean}
  2340.    */
  2342.   isScripthashInput() {
  2343.     if (this.code.length < 1)
  2344.       return false;
  2346.     // Grab the raw redeem script.
  2347.     const raw = this.getData(-1);
  2349.     // Last data element should be an array
  2350.     // for the redeem script.
  2351.     if (!raw)
  2352.       return false;
  2354.     // Testing for scripthash inputs requires
  2355.     // some evil magic to work. We do it by
  2356.     // ruling things _out_. This test will not
  2357.     // be correct 100% of the time. We rule
  2358.     // out that the last data element is: a
  2359.     // null dummy, a valid signature, a valid
  2360.     // key, and we ensure that it is at least
  2361.     // a script that does not use undefined
  2362.     // opcodes.
  2363.     if (raw.length === 0)
  2364.       return false;
  2366.     if (common.isSignatureEncoding(raw))
  2367.       return false;
  2369.     if (common.isKeyEncoding(raw))
  2370.       return false;
  2372.     const redeem = Script.fromRaw(raw);
  2374.     if (!redeem.isCode())
  2375.       return false;
  2377.     if (redeem.isUnspendable())
  2378.       return false;
  2380.     if (!this.isPushOnly())
  2381.       return false;
  2383.     return true;
  2384.   }
  2386.   /**
  2387.    * Get P2SH redeem script if present.
  2388.    * @returns {Buffer|null}
  2389.    */
  2391.   getScripthashInput() {
  2392.     if (!this.isScripthashInput())
  2393.       return null;
  2395.     return this.getData(-1);
  2396.   }
  2398.   /**
  2399.    * Get coinbase height.
  2400.    * @returns {Number} `-1` if not present.
  2401.    */
  2403.   getCoinbaseHeight() {
  2404.     return Script.getCoinbaseHeight(this.raw);
  2405.   }
  2407.   /**
  2408.    * Get coinbase height.
  2409.    * @param {Buffer} raw - Raw script.
  2410.    * @returns {Number} `-1` if not present.
  2411.    */
  2413.   static getCoinbaseHeight(raw) {
  2414.     if (raw.length === 0)
  2415.       return -1;
  2417.     if (raw[0] >= opcodes.OP_1 && raw[0] <= opcodes.OP_16)
  2418.       return raw[0] - 0x50;
  2420.     if (raw[0] > 0x06)
  2421.       return -1;
  2423.     const op = Opcode.fromRaw(raw);
  2424.     const num = op.toNum();
  2426.     if (!num)
  2427.       return 1;
  2429.     if (num.isNeg())
  2430.       return -1;
  2432.     if (!op.equals(Opcode.fromNum(num)))
  2433.       return -1;
  2435.     return num.toDouble();
  2436.   }
  2438.   /**
  2439.    * Test the script against a bloom filter.
  2440.    * @param {Bloom} filter
  2441.    * @returns {Boolean}
  2442.    */
  2444.   test(filter) {
  2445.     for (const op of this.code) {
  2446.       if (op.value === -1)
  2447.         break;
  2449.       if (!op.data || op.data.length === 0)
  2450.         continue;
  2452.       if (filter.test(op.data))
  2453.         return true;
  2454.     }
  2456.     return false;
  2457.   }
  2459.   /**
  2460.    * Test the script to see if it contains only push ops.
  2461.    * Push ops are: OP_1NEGATE, OP_0-OP_16 and all PUSHDATAs.
  2462.    * @returns {Boolean}
  2463.    */
  2465.   isPushOnly() {
  2466.     for (const op of this.code) {
  2467.       if (op.value === -1)
  2468.         return false;
  2470.       if (op.value > opcodes.OP_16)
  2471.         return false;
  2472.     }
  2474.     return true;
  2475.   }
  2477.   /**
  2478.    * Count the sigops in the script.
  2479.    * @param {Boolean} accurate - Whether to enable accurate counting. This will
  2480.    * take into account the `n` value for OP_CHECKMULTISIG(VERIFY).
  2481.    * @returns {Number} sigop count
  2482.    */
  2484.   getSigops(accurate) {
  2485.     let total = 0;
  2486.     let lastOp = -1;
  2488.     for (const op of this.code) {
  2489.       if (op.value === -1)
  2490.         break;
  2492.       switch (op.value) {
  2493.         case opcodes.OP_CHECKSIG:
  2494.         case opcodes.OP_CHECKSIGVERIFY:
  2495.           total += 1;
  2496.           break;
  2497.         case opcodes.OP_CHECKMULTISIG:
  2498.         case opcodes.OP_CHECKMULTISIGVERIFY:
  2499.           if (accurate && lastOp >= opcodes.OP_1 && lastOp <= opcodes.OP_16)
  2500.             total += lastOp - 0x50;
  2501.           else
  2502.             total += consensus.MAX_MULTISIG_PUBKEYS;
  2503.           break;
  2504.       }
  2506.       lastOp = op.value;
  2507.     }
  2509.     return total;
  2510.   }
  2512.   /**
  2513.    * Count the sigops in the script, taking into account redeem scripts.
  2514.    * @param {Script} input - Input script, needed for access to redeem script.
  2515.    * @returns {Number} sigop count
  2516.    */
  2518.   getScripthashSigops(input) {
  2519.     if (!this.isScripthash())
  2520.       return this.getSigops(true);
  2522.     const redeem = input.getRedeem();
  2524.     if (!redeem)
  2525.       return 0;
  2527.     return redeem.getSigops(true);
  2528.   }
  2530.   /**
  2531.    * Count the sigops in a script, taking into account witness programs.
  2532.    * @param {Script} input
  2533.    * @param {Witness} witness
  2534.    * @returns {Number} sigop count
  2535.    */
  2537.   getWitnessSigops(input, witness) {
  2538.     let program = this.getProgram();
  2540.     if (!program) {
  2541.       if (this.isScripthash()) {
  2542.         const redeem = input.getRedeem();
  2543.         if (redeem)
  2544.           program = redeem.getProgram();
  2545.       }
  2546.     }
  2548.     if (!program)
  2549.       return 0;
  2551.     if (program.version === 0) {
  2552.       if (program.data.length === 20)
  2553.         return 1;
  2555.       if (program.data.length === 32 && witness.items.length > 0) {
  2556.         const redeem = witness.getRedeem();
  2557.         return redeem.getSigops(true);
  2558.       }
  2559.     }
  2561.     return 0;
  2562.   }
  2564.   /*
  2565.    * Mutation
  2566.    */
  2568.   get(index) {
  2569.     if (index < 0)
  2570.       index += this.code.length;
  2572.     if (index < 0 || index >= this.code.length)
  2573.       return null;
  2575.     return this.code[index];
  2576.   }
  2578.   pop() {
  2579.     const op = this.code.pop();
  2580.     return op || null;
  2581.   }
  2583.   shift() {
  2584.     const op = this.code.shift();
  2585.     return op || null;
  2586.   }
  2588.   remove(index) {
  2589.     if (index < 0)
  2590.       index += this.code.length;
  2592.     if (index < 0 || index >= this.code.length)
  2593.       return null;
  2595.     const items = this.code.splice(index, 1);
  2597.     if (items.length === 0)
  2598.       return null;
  2600.     return items[0];
  2601.   }
  2603.   set(index, op) {
  2604.     if (index < 0)
  2605.       index += this.code.length;
  2607.     assert(Opcode.isOpcode(op));
  2608.     assert(index >= 0 && index <= this.code.length);
  2610.     this.code[index] = op;
  2612.     return this;
  2613.   }
  2615.   push(op) {
  2616.     assert(Opcode.isOpcode(op));
  2617.     this.code.push(op);
  2618.     return this;
  2619.   }
  2621.   unshift(op) {
  2622.     assert(Opcode.isOpcode(op));
  2623.     this.code.unshift(op);
  2624.     return this;
  2625.   }
  2627.   insert(index, op) {
  2628.     if (index < 0)
  2629.       index += this.code.length;
  2631.     assert(Opcode.isOpcode(op));
  2632.     assert(index >= 0 && index <= this.code.length);
  2634.     this.code.splice(index, 0, op);
  2636.     return this;
  2637.   }
  2639.   /*
  2640.    * Op
  2641.    */
  2643.   getOp(index) {
  2644.     const op = this.get(index);
  2645.     return op ? op.value : -1;
  2646.   }
  2648.   popOp() {
  2649.     const op = this.pop();
  2650.     return op ? op.value : -1;
  2651.   }
  2653.   shiftOp() {
  2654.     const op = this.shift();
  2655.     return op ? op.value : -1;
  2656.   }
  2658.   removeOp(index) {
  2659.     const op = this.remove(index);
  2660.     return op ? op.value : -1;
  2661.   }
  2663.   setOp(index, value) {
  2664.     return this.set(index, Opcode.fromOp(value));
  2665.   }
  2667.   pushOp(value) {
  2668.     return this.push(Opcode.fromOp(value));
  2669.   }
  2671.   unshiftOp(value) {
  2672.     return this.unshift(Opcode.fromOp(value));
  2673.   }
  2675.   insertOp(index, value) {
  2676.     return this.insert(index, Opcode.fromOp(value));
  2677.   }
  2679.   /*
  2680.    * Data
  2681.    */
  2683.   getData(index) {
  2684.     const op = this.get(index);
  2685.     return op ? op.data : null;
  2686.   }
  2688.   popData() {
  2689.     const op = this.pop();
  2690.     return op ? op.data : null;
  2691.   }
  2693.   shiftData() {
  2694.     const op = this.shift();
  2695.     return op ? op.data : null;
  2696.   }
  2698.   removeData(index) {
  2699.     const op = this.remove(index);
  2700.     return op ? op.data : null;
  2701.   }
  2703.   setData(index, data) {
  2704.     return this.set(index, Opcode.fromData(data));
  2705.   }
  2707.   pushData(data) {
  2708.     return this.push(Opcode.fromData(data));
  2709.   }
  2711.   unshiftData(data) {
  2712.     return this.unshift(Opcode.fromData(data));
  2713.   }
  2715.   insertData(index, data) {
  2716.     return this.insert(index, Opcode.fromData(data));
  2717.   }
  2719.   /*
  2720.    * Length
  2721.    */
  2723.   getLength(index) {
  2724.     const op = this.get(index);
  2725.     return op ? op.toLength() : -1;
  2726.   }
  2728.   /*
  2729.    * Push
  2730.    */
  2732.   getPush(index) {
  2733.     const op = this.get(index);
  2734.     return op ? op.toPush() : null;
  2735.   }
  2737.   popPush() {
  2738.     const op = this.pop();
  2739.     return op ? op.toPush() : null;
  2740.   }
  2742.   shiftPush() {
  2743.     const op = this.shift();
  2744.     return op ? op.toPush() : null;
  2745.   }
  2747.   removePush(index) {
  2748.     const op = this.remove(index);
  2749.     return op ? op.toPush() : null;
  2750.   }
  2752.   setPush(index, data) {
  2753.     return this.set(index, Opcode.fromPush(data));
  2754.   }
  2756.   pushPush(data) {
  2757.     return this.push(Opcode.fromPush(data));
  2758.   }
  2760.   unshiftPush(data) {
  2761.     return this.unshift(Opcode.fromPush(data));
  2762.   }
  2764.   insertPush(index, data) {
  2765.     return this.insert(index, Opcode.fromPush(data));
  2766.   }
  2768.   /*
  2769.    * String
  2770.    */
  2772.   getString(index, enc) {
  2773.     const op = this.get(index);
  2774.     return op ? op.toString(enc) : null;
  2775.   }
  2777.   popString(enc) {
  2778.     const op = this.pop();
  2779.     return op ? op.toString(enc) : null;
  2780.   }
  2782.   shiftString(enc) {
  2783.     const op = this.shift();
  2784.     return op ? op.toString(enc) : null;
  2785.   }
  2787.   removeString(index, enc) {
  2788.     const op = this.remove(index);
  2789.     return op ? op.toString(enc) : null;
  2790.   }
  2792.   setString(index, str, enc) {
  2793.     return this.set(index, Opcode.fromString(str, enc));
  2794.   }
  2796.   pushString(str, enc) {
  2797.     return this.push(Opcode.fromString(str, enc));
  2798.   }
  2800.   unshiftString(str, enc) {
  2801.     return this.unshift(Opcode.fromString(str, enc));
  2802.   }
  2804.   insertString(index, str, enc) {
  2805.     return this.insert(index, Opcode.fromString(str, enc));
  2806.   }
  2808.   /*
  2809.    * Small
  2810.    */
  2812.   getSmall(index) {
  2813.     const op = this.get(index);
  2814.     return op ? op.toSmall() : -1;
  2815.   }
  2817.   popSmall() {
  2818.     const op = this.pop();
  2819.     return op ? op.toSmall() : -1;
  2820.   }
  2822.   shiftSmall() {
  2823.     const op = this.shift();
  2824.     return op ? op.toSmall() : -1;
  2825.   }
  2827.   removeSmall(index) {
  2828.     const op = this.remove(index);
  2829.     return op ? op.toSmall() : -1;
  2830.   }
  2832.   setSmall(index, num) {
  2833.     return this.set(index, Opcode.fromSmall(num));
  2834.   }
  2836.   pushSmall(num) {
  2837.     return this.push(Opcode.fromSmall(num));
  2838.   }
  2840.   unshiftSmall(num) {
  2841.     return this.unshift(Opcode.fromSmall(num));
  2842.   }
  2844.   insertSmall(index, num) {
  2845.     return this.insert(index, Opcode.fromSmall(num));
  2846.   }
  2848.   /*
  2849.    * Num
  2850.    */
  2852.   getNum(index, minimal, limit) {
  2853.     const op = this.get(index);
  2854.     return op ? op.toNum(minimal, limit) : null;
  2855.   }
  2857.   popNum(minimal, limit) {
  2858.     const op = this.pop();
  2859.     return op ? op.toNum(minimal, limit) : null;
  2860.   }
  2862.   shiftNum(minimal, limit) {
  2863.     const op = this.shift();
  2864.     return op ? op.toNum(minimal, limit) : null;
  2865.   }
  2867.   removeNum(index, minimal, limit) {
  2868.     const op = this.remove(index);
  2869.     return op ? op.toNum(minimal, limit) : null;
  2870.   }
  2872.   setNum(index, num) {
  2873.     return this.set(index, Opcode.fromNum(num));
  2874.   }
  2876.   pushNum(num) {
  2877.     return this.push(Opcode.fromNum(num));
  2878.   }
  2880.   unshiftNum(num) {
  2881.     return this.unshift(Opcode.fromNum(num));
  2882.   }
  2884.   insertNum(index, num) {
  2885.     return this.insert(index, Opcode.fromNum(num));
  2886.   }
  2888.   /*
  2889.    * Int
  2890.    */
  2892.   getInt(index, minimal, limit) {
  2893.     const op = this.get(index);
  2894.     return op ? op.toInt(minimal, limit) : -1;
  2895.   }
  2897.   popInt(minimal, limit) {
  2898.     const op = this.pop();
  2899.     return op ? op.toInt(minimal, limit) : -1;
  2900.   }
  2902.   shiftInt(minimal, limit) {
  2903.     const op = this.shift();
  2904.     return op ? op.toInt(minimal, limit) : -1;
  2905.   }
  2907.   removeInt(index, minimal, limit) {
  2908.     const op = this.remove(index);
  2909.     return op ? op.toInt(minimal, limit) : -1;
  2910.   }
  2912.   setInt(index, num) {
  2913.     return this.set(index, Opcode.fromInt(num));
  2914.   }
  2916.   pushInt(num) {
  2917.     return this.push(Opcode.fromInt(num));
  2918.   }
  2920.   unshiftInt(num) {
  2921.     return this.unshift(Opcode.fromInt(num));
  2922.   }
  2924.   insertInt(index, num) {
  2925.     return this.insert(index, Opcode.fromInt(num));
  2926.   }
  2928.   /*
  2929.    * Bool
  2930.    */
  2932.   getBool(index) {
  2933.     const op = this.get(index);
  2934.     return op ? op.toBool() : false;
  2935.   }
  2937.   popBool() {
  2938.     const op = this.pop();
  2939.     return op ? op.toBool() : false;
  2940.   }
  2942.   shiftBool() {
  2943.     const op = this.shift();
  2944.     return op ? op.toBool() : false;
  2945.   }
  2947.   removeBool(index) {
  2948.     const op = this.remove(index);
  2949.     return op ? op.toBool() : false;
  2950.   }
  2952.   setBool(index, value) {
  2953.     return this.set(index, Opcode.fromBool(value));
  2954.   }
  2956.   pushBool(value) {
  2957.     return this.push(Opcode.fromBool(value));
  2958.   }
  2960.   unshiftBool(value) {
  2961.     return this.unshift(Opcode.fromBool(value));
  2962.   }
  2964.   insertBool(index, value) {
  2965.     return this.insert(index, Opcode.fromBool(value));
  2966.   }
  2968.   /*
  2969.    * Symbol
  2970.    */
  2972.   getSym(index) {
  2973.     const op = this.get(index);
  2974.     return op ? op.toSymbol() : null;
  2975.   }
  2977.   popSym() {
  2978.     const op = this.pop();
  2979.     return op ? op.toSymbol() : null;
  2980.   }
  2982.   shiftSym() {
  2983.     const op = this.shift();
  2984.     return op ? op.toSymbol() : null;
  2985.   }
  2987.   removeSym(index) {
  2988.     const op = this.remove(index);
  2989.     return op ? op.toSymbol() : null;
  2990.   }
  2992.   setSym(index, symbol) {
  2993.     return this.set(index, Opcode.fromSymbol(symbol));
  2994.   }
  2996.   pushSym(symbol) {
  2997.     return this.push(Opcode.fromSymbol(symbol));
  2998.   }
  3000.   unshiftSym(symbol) {
  3001.     return this.unshift(Opcode.fromSymbol(symbol));
  3002.   }
  3004.   insertSym(index, symbol) {
  3005.     return this.insert(index, Opcode.fromSymbol(symbol));
  3006.   }
  3008.   /**
  3009.    * Inject properties from bitcoind test string.
  3010.    * @private
  3011.    * @param {String} items - Script string.
  3012.    * @throws Parse error.
  3013.    */
  3015.   fromString(code) {
  3016.     assert(typeof code === 'string');
  3018.     code = code.trim();
  3020.     if (code.length === 0)
  3021.       return this;
  3023.     const items = code.split(/\s+/);
  3024.     const bw = bio.write();
  3026.     for (const item of items) {
  3027.       let symbol = item;
  3029.       if (symbol.charCodeAt(0) & 32)
  3030.         symbol = symbol.toUpperCase();
  3032.       if (!/^OP_/.test(symbol))
  3033.         symbol = `OP_${symbol}`;
  3035.       const value = opcodes[symbol];
  3037.       if (value == null) {
  3038.         if (item[0] === '\'') {
  3039.           assert(item[item.length - 1] === '\'', 'Invalid string.');
  3040.           const str = item.slice(1, -1);
  3041.           const op = Opcode.fromString(str);
  3042.           bw.writeBytes(op.toRaw());
  3043.           continue;
  3044.         }
  3046.         if (/^-?\d+$/.test(item)) {
  3047.           const num = ScriptNum.fromString(item, 10);
  3048.           const op = Opcode.fromNum(num);
  3049.           bw.writeBytes(op.toRaw());
  3050.           continue;
  3051.         }
  3053.         assert(item.indexOf('0x') === 0, 'Unknown opcode.');
  3055.         const hex = item.substring(2);
  3056.         const data = Buffer.from(hex, 'hex');
  3058.         assert(data.length === hex.length / 2, 'Invalid hex string.');
  3060.         bw.writeBytes(data);
  3062.         continue;
  3063.       }
  3065.       bw.writeU8(value);
  3066.     }
  3068.     return this.fromRaw(bw.render());
  3069.   }
  3071.   /**
  3072.    * Parse a bitcoind test script
  3073.    * string into a script object.
  3074.    * @param {String} items - Script string.
  3075.    * @returns {Script}
  3076.    * @throws Parse error.
  3077.    */
  3079.   static fromString(code) {
  3080.     return new this().fromString(code);
  3081.   }
  3083.   /**
  3084.    * Verify an input and output script, and a witness if present.
  3085.    * @param {Script} input
  3086.    * @param {Witness} witness
  3087.    * @param {Script} output
  3088.    * @param {TX} tx
  3089.    * @param {Number} index
  3090.    * @param {Amount} value
  3091.    * @param {VerifyFlags} flags
  3092.    * @throws {ScriptError}
  3093.    */
  3095.   static verify(input, witness, output, tx, index, value, flags) {
  3096.     if (flags == null)
  3097.       flags = Script.flags.STANDARD_VERIFY_FLAGS;
  3099.     if (flags & Script.flags.VERIFY_SIGPUSHONLY) {
  3100.       if (!input.isPushOnly())
  3101.         throw new ScriptError('SIG_PUSHONLY');
  3102.     }
  3104.     // Setup a stack.
  3105.     let stack = new Stack();
  3107.     // Execute the input script
  3108.     input.execute(stack, flags, tx, index, value, 0);
  3110.     // Copy the stack for P2SH
  3111.     let copy;
  3112.     if (flags & Script.flags.VERIFY_P2SH)
  3113.       copy = stack.clone();
  3115.     // Execute the previous output script.
  3116.     output.execute(stack, flags, tx, index, value, 0);
  3118.     // Verify the stack values.
  3119.     if (stack.length === 0 || !stack.getBool(-1))
  3120.       throw new ScriptError('EVAL_FALSE');
  3122.     let hadWitness = false;
  3124.     if ((flags & Script.flags.VERIFY_WITNESS) && output.isProgram()) {
  3125.       hadWitness = true;
  3127.       // Input script must be empty.
  3128.       if (input.raw.length !== 0)
  3129.         throw new ScriptError('WITNESS_MALLEATED');
  3131.       // Verify the program in the output script.
  3132.       Script.verifyProgram(witness, output, flags, tx, index, value);
  3134.       // Force a cleanstack
  3135.       stack.length = 1;
  3136.     }
  3138.     // If the script is P2SH, execute the real output script
  3139.     if ((flags & Script.flags.VERIFY_P2SH) && output.isScripthash()) {
  3140.       // P2SH can only have push ops in the scriptSig
  3141.       if (!input.isPushOnly())
  3142.         throw new ScriptError('SIG_PUSHONLY');
  3144.       // Reset the stack
  3145.       stack = copy;
  3147.       // Stack should not be empty at this point
  3148.       if (stack.length === 0)
  3149.         throw new ScriptError('EVAL_FALSE');
  3151.       // Grab the real redeem script
  3152.       const raw = stack.pop();
  3153.       const redeem = Script.fromRaw(raw);
  3155.       // Execute the redeem script.
  3156.       redeem.execute(stack, flags, tx, index, value, 0);
  3158.       // Verify the the stack values.
  3159.       if (stack.length === 0 || !stack.getBool(-1))
  3160.         throw new ScriptError('EVAL_FALSE');
  3162.       if ((flags & Script.flags.VERIFY_WITNESS) && redeem.isProgram()) {
  3163.         hadWitness = true;
  3165.         // Input script must be exactly one push of the redeem script.
  3166.         if (!input.raw.equals(Opcode.fromPush(raw).toRaw()))
  3167.           throw new ScriptError('WITNESS_MALLEATED_P2SH');
  3169.         // Verify the program in the redeem script.
  3170.         Script.verifyProgram(witness, redeem, flags, tx, index, value);
  3172.         // Force a cleanstack.
  3173.         stack.length = 1;
  3174.       }
  3175.     }
  3177.     // Ensure there is nothing left on the stack.
  3178.     if (flags & Script.flags.VERIFY_CLEANSTACK) {
  3179.       assert((flags & Script.flags.VERIFY_P2SH) !== 0);
  3180.       if (stack.length !== 1)
  3181.         throw new ScriptError('CLEANSTACK');
  3182.     }
  3184.     // If we had a witness but no witness program, fail.
  3185.     if (flags & Script.flags.VERIFY_WITNESS) {
  3186.       assert((flags & Script.flags.VERIFY_P2SH) !== 0);
  3187.       if (!hadWitness && witness.items.length > 0)
  3188.         throw new ScriptError('WITNESS_UNEXPECTED');
  3189.     }
  3190.   }
  3192.   /**
  3193.    * Verify a witness program. This runs after regular script
  3194.    * execution if a witness program is present. It will convert
  3195.    * the witness to a stack and execute the program.
  3196.    * @param {Witness} witness
  3197.    * @param {Script} output
  3198.    * @param {VerifyFlags} flags
  3199.    * @param {TX} tx
  3200.    * @param {Number} index
  3201.    * @param {Amount} value
  3202.    * @throws {ScriptError}
  3203.    */
  3205.   static verifyProgram(witness, output, flags, tx, index, value) {
  3206.     const program = output.getProgram();
  3208.     assert(program, 'verifyProgram called on non-witness-program.');
  3209.     assert((flags & Script.flags.VERIFY_WITNESS) !== 0);
  3211.     const stack = witness.toStack();
  3212.     let redeem;
  3214.     if (program.version === 0) {
  3215.       if (program.data.length === 32) {
  3216.         if (stack.length === 0)
  3217.           throw new ScriptError('WITNESS_PROGRAM_WITNESS_EMPTY');
  3219.         const witnessScript = stack.pop();
  3221.         if (!sha256.digest(witnessScript).equals(program.data))
  3222.           throw new ScriptError('WITNESS_PROGRAM_MISMATCH');
  3224.         redeem = Script.fromRaw(witnessScript);
  3225.       } else if (program.data.length === 20) {
  3226.         if (stack.length !== 2)
  3227.           throw new ScriptError('WITNESS_PROGRAM_MISMATCH');
  3229.         redeem = Script.fromPubkeyhash(program.data);
  3230.       } else {
  3231.         // Failure on version=0 (bad program data length).
  3232.         throw new ScriptError('WITNESS_PROGRAM_WRONG_LENGTH');
  3233.       }
  3234.     } else {
  3235.       // Anyone can spend (we can return true here
  3236.       // if we want to always relay these transactions).
  3237.       // Otherwise, if we want to act like an "old"
  3238.       // implementation and only accept them in blocks,
  3239.       // we can use the regular output script which will
  3240.       // succeed in a block, but fail in the mempool
  3241.       // due to VERIFY_CLEANSTACK.
  3242.       if (flags & Script.flags.VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
  3243.         throw new ScriptError('DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM');
  3244.       return;
  3245.     }
  3247.     // Witnesses still have push limits.
  3248.     for (let j = 0; j < stack.length; j++) {
  3249.       if (stack.get(j).length > consensus.MAX_SCRIPT_PUSH)
  3250.         throw new ScriptError('PUSH_SIZE');
  3251.     }
  3253.     // Verify the redeem script.
  3254.     redeem.execute(stack, flags, tx, index, value, 1);
  3256.     // Verify the stack values.
  3257.     if (stack.length !== 1)
  3258.       throw new ScriptError('CLEANSTACK');
  3260.     if (!stack.getBool(-1))
  3261.       throw new ScriptError('EVAL_FALSE');
  3262.   }
  3264.   /**
  3265.    * Inject properties from buffer reader.
  3266.    * @private
  3267.    * @param {BufferReader} br
  3268.    */
  3270.   fromReader(br) {
  3271.     return this.fromRaw(br.readVarBytes());
  3272.   }
  3274.   /**
  3275.    * Inject properties from serialized data.
  3276.    * @private
  3277.    * @param {Buffer}
  3278.    */
  3280.   fromRaw(data) {
  3281.     const br = bio.read(data);
  3283.     this.raw = data;
  3285.     while (br.left())
  3286.       this.code.push(Opcode.fromReader(br));
  3288.     return this;
  3289.   }
  3291.   /**
  3292.    * Create a script from buffer reader.
  3293.    * @param {BufferReader} br
  3294.    * @param {String?} enc - Either `"hex"` or `null`.
  3295.    * @returns {Script}
  3296.    */
  3298.   static fromReader(br) {
  3299.     return new this().fromReader(br);
  3300.   }
  3302.   /**
  3303.    * Create a script from a serialized buffer.
  3304.    * @param {Buffer|String} data - Serialized script.
  3305.    * @param {String?} enc - Either `"hex"` or `null`.
  3306.    * @returns {Script}
  3307.    */
  3309.   static fromRaw(data, enc) {
  3310.     if (typeof data === 'string')
  3311.       data = Buffer.from(data, enc);
  3312.     return new this().fromRaw(data);
  3313.   }
  3315.   /**
  3316.    * Test whether an object a Script.
  3317.    * @param {Object} obj
  3318.    * @returns {Boolean}
  3319.    */
  3321.   static isScript(obj) {
  3322.     return obj instanceof Script;
  3323.   }
  3324. }
  3326. /**
  3327.  * Script opcodes.
  3328.  * @enum {Number}
  3329.  * @default
  3330.  */
  3332. Script.opcodes = common.opcodes;
  3334. /**
  3335.  * Opcodes by value.
  3336.  * @const {RevMap}
  3337.  */
  3339. Script.opcodesByVal = common.opcodesByVal;
  3341. /**
  3342.  * Script and locktime flags. See {@link VerifyFlags}.
  3343.  * @enum {Number}
  3344.  */
  3346. Script.flags = common.flags;
  3348. /**
  3349.  * Sighash Types.
  3350.  * @enum {SighashType}
  3351.  * @default
  3352.  */
  3354. Script.hashType = common.hashType;
  3356. /**
  3357.  * Sighash types by value.
  3358.  * @const {RevMap}
  3359.  */
  3361. Script.hashTypeByVal = common.hashTypeByVal;
  3363. /**
  3364.  * Output script types.
  3365.  * @enum {Number}
  3366.  */
  3368. Script.types = common.types;
  3370. /**
  3371.  * Output script types by value.
  3372.  * @const {RevMap}
  3373.  */
  3375. Script.typesByVal = common.typesByVal;
  3377. /*
  3378.  * Helpers
  3379.  */
  3381. function sortKeys(keys) {
  3382.   return keys.slice().sort((a, b) => {
  3383.     return a.compare(b);
  3384.   });
  3385. }
  3387. /**
  3388.  * Test whether the data element is a valid key if VERIFY_STRICTENC is enabled.
  3389.  * @param {Buffer} key
  3390.  * @param {VerifyFlags?} flags
  3391.  * @returns {Boolean}
  3392.  * @throws {ScriptError}
  3393.  */
  3395. function validateKey(key, flags, version) {
  3396.   assert(Buffer.isBuffer(key));
  3397.   assert(typeof flags === 'number');
  3398.   assert(typeof version === 'number');
  3400.   if (flags & Script.flags.VERIFY_STRICTENC) {
  3401.     if (!common.isKeyEncoding(key))
  3402.       throw new ScriptError('PUBKEYTYPE');
  3403.   }
  3405.   if (version === 1) {
  3406.     if (flags & Script.flags.VERIFY_WITNESS_PUBKEYTYPE) {
  3407.       if (!common.isCompressedEncoding(key))
  3408.         throw new ScriptError('WITNESS_PUBKEYTYPE');
  3409.     }
  3410.   }
  3412.   return true;
  3413. }
  3415. /**
  3416.  * Test whether the data element is a valid signature based
  3417.  * on the encoding, S value, and sighash type. Requires
  3418.  * VERIFY_DERSIG|VERIFY_LOW_S|VERIFY_STRICTENC, VERIFY_LOW_S
  3419.  * and VERIFY_STRING_ENC to be enabled respectively. Note that
  3420.  * this will allow zero-length signatures.
  3421.  * @param {Buffer} sig
  3422.  * @param {VerifyFlags?} flags
  3423.  * @returns {Boolean}
  3424.  * @throws {ScriptError}
  3425.  */
  3427. function validateSignature(sig, flags) {
  3428.   assert(Buffer.isBuffer(sig));
  3429.   assert(typeof flags === 'number');
  3431.   // Allow empty sigs
  3432.   if (sig.length === 0)
  3433.     return true;
  3435.   if ((flags & Script.flags.VERIFY_DERSIG)
  3436.       || (flags & Script.flags.VERIFY_LOW_S)
  3437.       || (flags & Script.flags.VERIFY_STRICTENC)) {
  3438.     if (!common.isSignatureEncoding(sig))
  3439.       throw new ScriptError('SIG_DER');
  3440.   }
  3442.   if (flags & Script.flags.VERIFY_LOW_S) {
  3443.     if (!common.isLowDER(sig))
  3444.       throw new ScriptError('SIG_HIGH_S');
  3445.   }
  3447.   if (flags & Script.flags.VERIFY_STRICTENC) {
  3448.     if (!common.isHashType(sig))
  3449.       throw new ScriptError('SIG_HASHTYPE');
  3450.   }
  3452.   return true;
  3453. }
  3455. /**
  3456.  * Verify a signature, taking into account sighash type.
  3457.  * @param {Buffer} msg - Signature hash.
  3458.  * @param {Buffer} sig
  3459.  * @param {Buffer} key
  3460.  * @returns {Boolean}
  3461.  */
  3463. function checksig(msg, sig, key) {
  3464.   return secp256k1.verifyDER(msg, sig.slice(0, -1), key);
  3465. }
  3467. /*
  3468.  * Expose
  3469.  */
  3471. module.exports = Script;