/**
 * script.js - script interpreter for bcoin
 * Copyright (c) 2014-2015, Fedor Indutny (MIT License)
 * https://github.com/indutny/bcoin
 */

var bcoin = require('../bcoin');
var bn = require('bn.js');
var constants = bcoin.protocol.constants;
var utils = bcoin.utils;
var assert = bcoin.utils.assert;
var script = exports;

/**
 * Script
 */

script.decode = function decode(buf) {
  var opcodes = [];
  var i = 0;
  var b, opcode, len;

  if (!buf)
    return [];

  while (i < buf.length) {
    b = buf[i++];

    // Next `b` bytes should be pushed to stack
    if (b >= 0x01 && b <= 0x4b) {
      opcodes.push(utils.slice(buf, i, i + b));
      i += b;
      utils.hidden(opcodes[opcodes.length - 1], 'pushdata', {
        opcode: null,
        len: b
      });
      continue;
    }

    // OP_0, OP_FALSE
    // Special case: this is an empty array
    // because it can be seen as an empty pushdata.
    if (b === 0x00) {
      opcodes.push(0);
      continue;
    }

    // OP_1, OP_TRUE, OP_2-OP_16
    // Special case: these get to be number
    // literals. Note: 1negate is not included.
    if (b >= 0x51 && b <= 0x60) {
      opcodes.push(b - 0x50);
      continue;
    }

    opcode = constants.opcodesByVal[b];

    if (i >= buf.length) {
      opcodes.push(opcode || b);
      continue;
    }

    if (opcode === 'pushdata1') {
      len = buf[i];
      i += 1;
      opcodes.push(utils.slice(buf, i, i + len));
      i += len;
      utils.hidden(opcodes[opcodes.length - 1], 'pushdata', {
        opcode: opcode,
        len: len
      });
    } else if (opcode === 'pushdata2') {
      len = utils.readU16(buf, i);
      i += 2;
      opcodes.push(utils.slice(buf, i, i + len));
      i += len;
      utils.hidden(opcodes[opcodes.length - 1], 'pushdata', {
        opcode: opcode,
        len: len
      });
    } else if (opcode === 'pushdata4') {
      len = utils.readU32(buf, i);
      i += 4;
      opcodes.push(utils.slice(buf, i, i + len));
      i += len;
      utils.hidden(opcodes[opcodes.length - 1], 'pushdata', {
        opcode: opcode,
        len: len
      });
    } else {
      opcodes.push(opcode || b);
    }
  }

  utils.hidden(opcodes, '_raw', utils.slice(buf));

  return opcodes;
};

script.encode = function encode(s) {
  var opcodes = constants.opcodes;
  var i = 0;
  var instr;
  var total = 0;
  var off = 0;
  var res;

  if (!s)
    return new Buffer([]);

  if (s._raw)
    return s._raw;

  for (i = 0; i < s.length; i++) {
    instr = s[i];

    if (Buffer.isBuffer(instr)) {
      if (instr.pushdata) {
        if (instr.pushdata.opcode === null) {
          total += 1 + instr.length;
        } else if (instr.pushdata.opcode === 'pushdata1') {
          total += 1 + 1 + instr.length;
        } else if (instr.pushdata.opcode === 'pushdata2') {
          total += 1 + 2 + instr.length;
        } else if (instr.pushdata.opcode === 'pushdata4') {
          total += 1 + 4 + instr.length;
        }
        continue;
      }
      if (instr.length === 0) {
        total += 1;
      } else if (1 <= instr.length && instr.length <= 0x4b) {
        total += 1 + instr.length;
      } else if (instr.length <= 0xff) {
        total += 1 + 1 + instr.length;
      } else if (instr.length <= 0xffff) {
        total += 1 + 2 + instr.length;
      } else {
        total += 1 + 4 + instr.length;
      }
      continue;
    }

    total += 1;
  }

  res = new Buffer(total);

  for (i = 0; i < s.length; i++) {
    instr = s[i];

    assert(!Array.isArray(instr));

    // Push value to stack
    if (Buffer.isBuffer(instr)) {
      // Check for nonstandard pushdatas that
      // may have been decoded from before.
      if (instr.pushdata) {
        if (instr.pushdata.opcode === null) {
          res[off++] = instr.pushdata.len;
          off += instr.copy(res, off, 0, instr.length);
        } else if (instr.pushdata.opcode === 'pushdata1') {
          res[off++] = opcodes.pushdata1;
          res[off++] = instr.pushdata.len;
          off += instr.copy(res, off, 0, instr.length);
        } else if (instr.pushdata.opcode === 'pushdata2') {
          res[off++] = opcodes.pushdata2;
          off += utils.writeU16(res, instr.pushdata.len, off);
          off += instr.copy(res, off, 0, instr.length);
        } else if (instr.pushdata.opcode === 'pushdata4') {
          res[off++] = opcodes.pushdata4;
          off += utils.writeU32(res, instr.pushdata.len, off);
          off += instr.copy(res, off, 0, instr.length);
        }
        continue;
      }
      if (instr.length === 0) {
        res[off++] = opcodes['0'];
      } else if (1 <= instr.length && instr.length <= 0x4b) {
        res[off++] = instr.length;
        off += instr.copy(res, off, 0, instr.length);
      } else if (instr.length <= 0xff) {
        res[off++] = opcodes.pushdata1;
        res[off++] = instr.length;
        off += instr.copy(res, off, 0, instr.length);
      } else if (instr.length <= 0xffff) {
        res[off++] = opcodes.pushdata2;
        off += utils.writeU16(res, instr.length, off);
        off += instr.copy(res, off, 0, instr.length);
      } else {
        res[off++] = opcodes.pushdata4;
        off += utils.writeU32(res, instr.length, off);
        off += instr.copy(res, off, 0, instr.length);
      }
      continue;
    }

    assert(opcodes[instr] != null || typeof instr === 'number');

    res[off++] = opcodes[instr] || instr;
  }

  assert(off === res.length);

  return res;
};

// Witnesses aren't scripts, but we still
// want to convert [0] to OP_0, [0xff] to 1negate, etc.
script.decodeWitness = function decodeWitness(witness) {
  var s = [];
  var chunk, i;

  for (i = 0; i < witness.length; i++) {
    chunk = witness[i];

    if (chunk.length <= 1) {
      if (chunk.length === 0)
        op = new Buffer([]);
      else if (chunk[0] >= 1 && chunk <= 16)
        op = chunk[0];
      else if (chunk[0] === 0xff)
        op = '1negate';
    }

    s.push(op);
  }

  return s;
};

script.encodeWitness = function encodeWitness(s) {
  var witness = [];
  var chunk, i;

  for (i = 0; i < s.length; i++) {
    chunk = s[i];

    if (chunk === 0)
      chunk = new Buffer([]);
    else if (chunk >= 1 && chunk <= 16)
      chunk = new Buffer([chunk]);
    else if (chunk === '1negate')
      chunk = new Buffer([0xff]);

    assert(Buffer.isBuffer(chunk));

    witness.push(chunk);
  }

  return witness;
};

script.normalize = function normalize(s) {
  var i, op;

  // Remove OP_ prefixes and lowercase
  for (i = 0; i < s.length; i++) {
    op = s[i];
    if (typeof op === 'string') {
      op = op.toLowerCase();
      if (op.indexOf('op_') === 0)
        op = op.slice(3);
    }
    s[i] = op;
  }

  // Convert OP_0 to array, convert OP_1-OP_16
  // to number literals, convert -1 to OP_1NEGATE.
  // Convert hex strings to arrays.
  for (i = 0; i < s.length; i++) {
    op = s[i];

    if (op === '-1' || op === -1)
      op = '1negate';
    else if (op === '0' || op === 0 || op === 'false')
      op = [];
    else if (op === 'true')
      op = 1;
    else if (+op >= 1 && +op <= 16)
      op = +op;

    if (typeof op === 'string' && constants.opcodes[op] == null) {
      if (op[0] === '[')
        op = op.slice(1, -1);
      op = new Buffer(op, 'hex');
    }

    s[i] = op;
  }

  return s;
};

script.verify = function verify(input, witness, output, tx, i, flags) {
  var copy, res, raw, redeem, hadWitness;
  var stack = [];

  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (flags & constants.flags.VERIFY_SIGPUSHONLY) {
    if (!script.isPushOnly(input))
      return false;
  }

  // Execute the input script
  script.execute(input, stack, tx, i, flags, 0);

  // Copy the stack for P2SH
  if (flags & constants.flags.VERIFY_P2SH)
    copy = stack.slice();

  // Execute the previous output script
  res = script.execute(output, stack, tx, i, flags, 0);

  // Verify the script did not fail as well as the stack values
  if (!res || stack.length === 0 || !script.bool(stack.pop()))
    return false;

  if ((flags & constants.flags.VERIFY_WITNESS)
      && script.isWitnessProgram(output)) {
    hadWitness = true;

    // Input script must be empty.
    if (input.length !== 0)
      return false;

    // Verify the program in the output script
    if (!script.verifyProgram(witness, output, tx, i, flags))
      return false;

    // Force a cleanstack
    stack.length = 0;
  }

  // If the script is P2SH, execute the real output script
  if ((flags & constants.flags.VERIFY_P2SH) && script.isScripthash(output)) {
    // P2SH can only have push ops in the scriptSig
    if (!script.isPushOnly(input))
      return false;

    // Reset the stack
    stack = copy;

    // Stack should not be empty at this point
    if (stack.length === 0)
      return false;

    // Grab the real redeem script
    raw = stack.pop();

    if (!Buffer.isBuffer(raw))
      return false;

    redeem = script.decode(raw);

    // Execute the redeem script
    res = script.execute(redeem, stack, tx, i, flags, 0);

    // Verify the script did not fail as well as the stack values
    if (!res || stack.length === 0 || !script.bool(stack.pop()))
      return false;

    if ((flags & constants.flags.VERIFY_WITNESS)
        && script.isWitnessProgram(redeem)) {
      hadWitness = true;

      // Input script must be exactly one push of the redeem script.
      if (!(input.length === 1 && utils.isEqual(input[0], raw)))
        return false;

      // Verify the program in the redeem script
      if (!script.verifyProgram(witness, redeem, tx, i, flags))
        return false;

      // Force a cleanstack
      stack.length = 0;
    }
  }

  // Ensure there is nothing left on the stack
  if (flags & constants.flags.VERIFY_CLEANSTACK) {
    assert((flags & constants.flags.VERIFY_P2SH) !== 0);
    // assert((flags & constants.flags.VERIFY_WITNESS) !== 0);
    if (stack.length !== 0)
      return false;
  }

  // If we had a witness but no witness program, fail.
  if (flags & constants.flags.VERIFY_WITNESS) {
    assert((flags & constants.flags.VERIFY_P2SH) !== 0);
    if (!hadWitness && witness.length > 0)
      return false;
  }

  return true;
};

script.verifyProgram = function verifyProgram(witness, output, tx, i, flags) {
  var program, witnessScript, redeem, stack, j;

  assert((flags & constants.flags.VERIFY_WITNESS) !== 0);
  assert(script.isWitnessProgram(output));

  program = script.getWitnessProgram(output);

  // Failure on version=0 (bad program data length)
  if (!program.type) {
    utils.debug('Malformed witness program.');
    return false;
  }

  if (program.version > 0) {
    utils.debug('Unknown witness program version: %s', program.version);
    // Anyone can spend (we can return true here
    // if we want to always relay these transactions).
    // Otherwise, if we want to act like an "old"
    // implementation and only accept them in blocks,
    // we can use the regalar output script which will
    // succeed in a block, but fail in the mempool
    // due to VERIFY_CLEANSTACK.
    if (flags & constants.flags.VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
      return false;
    return true;
  }

  stack = witness.slice();

  if (program.type === 'witnesspubkeyhash') {
    if (stack.length !== 2)
      return false;

    redeem = script.createPubkeyhash(program.data);
  } else if (program.type === 'witnessscripthash') {
    if (stack.length === 0)
      return false;

    witnessScript = stack.pop();

    if (!utils.isEqual(utils.sha256(witnessScript), program.data))
      return false;

    redeem = script.decode(witnessScript);
  } else {
    assert(false);
  }

  for (j = 0; j < stack.length; j++) {
    if (stack[j].length > constants.script.maxSize)
      return false;
  }

  res = script.execute(redeem, stack, tx, i, flags, 1);

  // Verify the script did not fail as well as the stack values
  if (!res || stack.length === 0 || !script.bool(stack.pop()))
    return false;

  // Witnesses always require cleanstack
  if (stack.length !== 0)
    return false;

  return true;
};

script.getSubscript = function getSubscript(s, lastSep) {
  var i, res;

  if (!s)
    return [];

  if (lastSep == null)
    lastSep = -1;

  assert(lastSep <= 0 || s[lastSep] === 'codeseparator');

  res = [];
  for (i = lastSep + 1; i < s.length; i++) {
    if (s[i] !== 'codeseparator')
      res.push(s[i]);
  }

  if (res.length === s.length)
    return s;

  return res;
};

script.concat = function concat(scripts) {
  var s = [];
  var i;

  s = s.concat(scripts[0]);

  for (i = 1; i < scripts.length; i++) {
    s.push('codeseparator');
    s = s.concat(scripts[i]);
  }

  return s;
};

script.checksig = function checksig(msg, sig, key, flags) {
  var historical = false;

  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (!Buffer.isBuffer(sig))
    return false;

  if (sig.length === 0)
    return false;

  // Attempt to normalize the signature
  // length before passing to elliptic.
  // Note: We only do this for historical data!
  // https://github.com/indutny/elliptic/issues/78
  if (!((flags & constants.flags.VERIFY_DERSIG)
      || (flags & constants.flags.VERIFY_LOW_S)
      || (flags & constants.flags.VERIFY_STRICTENC))) {
    historical = true;
  }

  return bcoin.ec.verify(msg, sig.slice(0, -1), key, historical);
};

script.sign = function sign(msg, key, type) {
  var sig = bcoin.ec.sign(msg, key);

  // Add the sighash type as a single byte
  // to the signature.
  sig = Buffer.concat([sig, new Buffer([type])]);

  return sig;
};

script._next = function _next(to, s, pc) {
  var depth = 0;
  var o;

  while (s[pc]) {
    o = s[pc];

    if (o === 'if' || o === 'notif')
      depth++;
    else if (o === 'else')
      depth--;
    else if (o === 'endif')
      depth--;

    if (depth < 0)
      break;

    if (depth === 0 && o === to)
      return pc;

    if (o === 'else')
      depth++;

    pc++;
  }

  return -1;
};

script.execute = function execute(data, stack, tx, index, flags, version, recurse) {
  try {
    return script._execute(data, stack, tx, index, flags, version, recurse);
  } catch (e) {
    utils.debug('Script error: %s.', e.message);
    return false;
  }
};

script._execute = function _execute(data, stack, tx, index, flags, version, recurse) {
  var s = data.slice();
  var lastSep = -1;
  var pc = 0;
  var o, val;
  var if_, else_, endif;
  var v1, v2, v3, v4;
  var n, n1, n2, n3;
  var res;
  var key, sig, type, subscript, hash;
  var keys, i, j, m;
  var succ;
  var locktime, threshold;
  var evalScript;

  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (s.length > constants.script.maxOps)
    return false;

  if (!stack.alt)
    stack.alt = [];

  for (pc = 0; pc < s.length; pc++) {
    o = s[pc];

    if (Buffer.isBuffer(o)) {
      if (o.length > constants.script.maxPush)
        return false;
      if (!script.checkPush(o, flags))
        return false;
      stack.push(o);
      continue;
    }

    if (o === 0) {
      stack.push(new Buffer([]));
      continue;
    }

    if (o >= 1 && o <= 16) {
      stack.push(new Buffer([o]));
      continue;
    }

    switch (o) {
      case 'nop':
      case 'nop1':
      case 'nop4':
      case 'nop5':
      case 'nop6':
      case 'nop7':
      case 'nop8':
      case 'nop9':
      case 'nop10': {
        if (flags & constants.flags.VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
          return false;
        break;
      }
      case '1negate': {
        stack.push(new Buffer([0xff]));
        break;
      }
      case 'if':
      case 'notif': {
        if (stack.length < 1)
          return false;
        val = script.bool(stack.pop());
        if (o === 'notif')
          val = !val;
        if_ = pc;
        else_ = script._next('else', s, pc);
        endif = script._next('endif', s, pc);
        // Splice out the statement blocks we don't need
        if (val) {
          if (endif === -1)
            return false;
          if (else_ === -1) {
            s.splice(endif, 1);
            s.splice(if_, 1);
          } else {
            s.splice(else_, (endif - else_) + 1);
            s.splice(if_, 1);
          }
        } else {
          if (endif === -1)
            return false;
          if (else_ === -1) {
            s.splice(if_, (endif - if_) + 1);
          } else {
            s.splice(endif, 1);
            s.splice(if_, (else_ - if_) + 1);
          }
        }
        // Subtract one since we removed the if/notif opcode
        pc--;
        break;
      }
      case 'else': {
        return false;
      }
      case 'endif': {
        return false;
      }
      case 'verify': {
        if (stack.length === 0)
          return false;
        if (!script.bool(stack.pop()))
          return false;
        break;
      }
      case 'return': {
        return false;
      }
      case 'toaltstack': {
        if (stack.length === 0)
          return false;
        stack.alt.push(stack.pop());
        break;
      }
      case 'fromaltstack': {
        if (stack.alt.length === 0)
          return false;
        stack.push(stack.alt.pop());
        break;
      }
      case 'ifdup': {
        if (stack.length === 0)
          return false;
        if (script.bool(stack[stack.length - 1]))
          stack.push(script.array(stack[stack.length - 1]));
        break;
      }
      case 'depth': {
        stack.push(script.array(stack.length));
        break;
      }
      case 'drop': {
        if (stack.length === 0)
          return false;
        stack.pop();
        break;
      }
      case 'dup': {
        if (stack.length === 0)
          return false;
        stack.push(stack[stack.length - 1]);
        break;
      }
      case 'nip': {
        if (stack.length < 2)
          return false;
        stack.splice(stack.length - 2, 1);
        break;
      }
      case 'over': {
        if (stack.length < 2)
          return false;
        stack.push(stack[stack.length - 2]);
        break;
      }
      case 'pick':
      case 'roll': {
        if (stack.length < 2)
          return false;
        val = stack.pop();
        n = script.num(val, flags).toNumber();
        if (n < 0 || n >= stack.length)
          return false;
        val = stack[-n - 1];
        if (o === 'roll')
          stack.splice(stack.length - n - 1, 1);
        stack.push(val);
        break;
      }
      case 'rot': {
        if (stack.length < 3)
          return false;
        v3 = stack[stack.length - 3];
        v2 = stack[stack.length - 2];
        v1 = stack[stack.length - 1];
        stack[stack.length - 3] = v2;
        stack[stack.length - 2] = v3;
        v2 = stack[stack.length - 2];
        stack[stack.length - 2] = v1;
        stack[stack.length - 1] = v2;
        break;
      }
      case 'swap': {
        if (stack.length < 2)
          return false;
        v1 = stack[stack.length - 2];
        v2 = stack[stack.length - 1];
        stack[stack.length - 2] = v2;
        stack[stack.length - 1] = v1;
        break;
      }
      case 'tuck': {
        if (stack.length < 2)
          return false;
        stack.splice(stack.length - 2, 0, stack[stack.length - 1]);
        break;
      }
      case '2drop': {
        if (stack.length < 2)
          return false;
        stack.pop();
        stack.pop();
        break;
      }
      case '2dup': {
        if (stack.length < 2)
          return false;
        v1 = stack[stack.length - 2];
        v2 = stack[stack.length - 1];
        stack.push(v1);
        stack.push(v2);
        break;
      }
      case '3dup': {
        if (stack.length < 3)
          return false;
        v1 = stack[stack.length - 3];
        v2 = stack[stack.length - 2];
        v3 = stack[stack.length - 1];
        stack.push(v1);
        stack.push(v2);
        stack.push(v3);
        break;
      }
      case '2over': {
        if (stack.length < 4)
          return false;
        v1 = stack[stack.length - 4];
        v2 = stack[stack.length - 3];
        stack.push(v1);
        stack.push(v2);
        break;
      }
      case '2rot': {
        if (stack.length < 6)
          return false;
        v1 = stack[stack.length - 6];
        v2 = stack[stack.length - 5];
        stack.splice(stack.length - 6, 2);
        stack.push(v1);
        stack.push(v2);
        break;
      }
      case '2swap': {
        if (stack.length < 4)
          return false;
        v4 = stack[stack.length - 4];
        v3 = stack[stack.length - 3];
        v2 = stack[stack.length - 2];
        v1 = stack[stack.length - 1];
        stack[stack.length - 4] = v2;
        stack[stack.length - 2] = v4;
        stack[stack.length - 3] = v1;
        stack[stack.length - 1] = v3;
        break;
      }
      case 'size': {
        if (stack.length < 1)
          return false;
        stack.push(script.array(stack[stack.length - 1].length || 0));
        break;
      }
      case '1add':
      case '1sub':
      case 'negate':
      case 'abs':
      case 'not':
      case '0notequal': {
        if (stack.length < 1)
          return false;
        n = script.num(stack.pop(), flags);
        switch (o) {
          case '1add':
            n.iadd(1);
            break;
          case '1sub':
            n.isub(1);
            break;
          case 'negate':
            n = n.neg();
            break;
          case 'abs':
            if (n.cmpn(0) < 0)
              n = n.neg();
            break;
          case 'not':
            n = n.cmpn(0) === 0;
            break;
          case '0notequal':
            n = n.cmpn(0) !== 0;
            break;
          default:
            return false;
        }
        if (typeof n === 'boolean')
          n = new bn(n ? 1 : 0, 'le');
        stack.push(script.array(n));
        break;
      }
      case 'add':
      case 'sub':
      case 'booland':
      case 'boolor':
      case 'numequal':
      case 'numequalverify':
      case 'numnotequal':
      case 'lessthan':
      case 'greaterthan':
      case 'lessthanorequal':
      case 'greaterthanorequal':
      case 'min':
      case 'max': {
        switch (o) {
          case 'add':
          case 'sub':
          case 'booland':
          case 'boolor':
          case 'numequal':
          case 'numequalverify':
          case 'numnotequal':
          case 'lessthan':
          case 'greaterthan':
          case 'lessthanorequal':
          case 'greaterthanorequal':
          case 'min':
          case 'max':
            if (stack.length < 2)
              return false;
            n2 = script.num(stack.pop(), flags);
            n1 = script.num(stack.pop(), flags);
            n = new bn(0, 'le');
            switch (o) {
              case 'add':
                n = n1.add(n2);
                break;
              case 'sub':
                n = n1.sub(n2);
                break;
              case 'booland':
                n = n1.cmpn(0) !== 0 && n2.cmpn(0) !== 0;
                break;
              case 'boolor':
                n = n1.cmpn(0) !== 0 || n2.cmpn(0) !== 0;
                break;
              case 'numequal':
                n = n1.cmp(n2) === 0;
                break;
              case 'numequalverify':
                n = n1.cmp(n2) === 0;
                break;
              case 'numnotequal':
                n = n1.cmp(n2) !== 0;
                break;
              case 'lessthan':
                n = n1.cmp(n2) < 0;
                break;
              case 'greaterthan':
                n = n1.cmp(n2) > 0;
                break;
              case 'lessthanorequal':
                n = n1.cmp(n2) <= 0;
                break;
              case 'greaterthanorequal':
                n = n1.cmp(n2) >= 0;
                break;
              case 'min':
                n = n1.cmp(n2) < 0 ? n1 : n2;
                break;
              case 'max':
                n = n1.cmp(n2) > 0 ? n1 : n2;
                break;
              default:
                return false;
            }
            if (typeof n === 'boolean')
              n = new bn(n ? 1 : 0, 'le');
            res = script.bool(n);
            if (o === 'numequalverify') {
              if (!res)
                return false;
            } else {
              stack.push(script.array(n));
            }
            break;
          case 'within':
            if (stack.length < 3)
              return false;
            n3 = script.num(stack.pop(), flags);
            n2 = script.num(stack.pop(), flags);
            n1 = script.num(stack.pop(), flags);
            val = n2.cmp(n1) <= 0 && n1.cmp(n3) < 0;
            stack.push(val.cmpn(0) !== 0 ? new Buffer([1]) : new Buffer([]));
            break;
        }

        break;
      }
      case 'codeseparator': {
        lastSep = pc;
        break;
      }
      case 'ripemd160': {
        if (stack.length === 0)
          return false;
        stack.push(utils.ripemd160(stack.pop()));
        break;
      }
      case 'sha1': {
        if (stack.length === 0)
          return false;
        stack.push(utils.sha1(stack.pop()));
        break;
      }
      case 'sha256': {
        if (stack.length === 0)
          return false;
        stack.push(utils.sha256(stack.pop()));
        break;
      }
      case 'hash256': {
        if (stack.length === 0)
          return false;
        stack.push(utils.dsha256(stack.pop()));
        break;
      }
      case 'hash160': {
        if (stack.length === 0)
          return false;
        stack.push(utils.ripesha(stack.pop()));
        break;
      }
      case 'equalverify':
      case 'equal': {
        if (stack.length < 2)
          return false;
        res = utils.isEqual(stack.pop(), stack.pop());
        if (o === 'equalverify') {
          if (!res)
            return false;
        } else {
          stack.push(res ? new Buffer([1]) : new Buffer([]));
        }
        break;
      }
      case 'checksigverify':
      case 'checksig': {
        if (!tx || stack.length < 2)
          return false;

        key = stack.pop();
        sig = stack.pop();

        if (!script.isValidKey(key, flags))
          return false;

        if (!script.isValidSignature(sig, flags))
          return false;

        type = sig[sig.length - 1];

        subscript = script.getSubscript(data, lastSep);
        script.removeData(subscript, sig);

        hash = tx.signatureHash(index, subscript, type, version);

        res = script.checksig(hash, sig, key, flags);
        if (o === 'checksigverify') {
          if (!res)
            return false;
        } else {
          stack.push(res ? new Buffer([1]) : new Buffer([]));
        }

        break;
      }
      case 'checkmultisigverify':
      case 'checkmultisig': {
        if (!tx || stack.length < 4)
          return false;

        n = script.num(stack.pop(), flags).toNumber();

        if (!(n >= 1 && n <= 15))
          return false;

        if (stack.length < n + 1)
          return false;

        keys = [];
        for (i = 0; i < n; i++) {
          key = stack.pop();

          if (!script.isValidKey(key, flags))
            return false;

          keys.push(key);
        }

        m = script.num(stack.pop(), flags).toNumber();

        if (!(m >= 1 && m <= n))
          return false;

        if (stack.length < m)
          return false;

        subscript = script.getSubscript(data, lastSep);

        for (i = 0; i < m; i++) {
          sig = stack[stack.length - 1 - i];
          script.removeData(subscript, sig);
        }

        succ = 0;
        for (i = 0, j = 0; i < m; i++) {
          sig = stack.pop();

          if (!script.isValidSignature(sig, flags))
            return false;

          type = sig[sig.length - 1];

          hash = tx.signatureHash(index, subscript, type, version);

          res = false;
          for (; !res && j < n; j++)
            res = script.checksig(hash, sig, keys[j], flags);

          if (res)
            succ++;
        }

        if (stack.length < 1)
          return false;

        val = stack.pop();

        if (flags & constants.flags.VERIFY_NULLDUMMY) {
          if (!script.isDummy(val))
            return false;
        }

        res = succ >= m;

        if (!res)
          utils.debug('checkmultisig failed: succ: %d, m: %d', succ, m);

        if (o === 'checkmultisigverify') {
          if (!res)
            return false;
        } else {
          stack.push(res ? new Buffer([1]) : new Buffer([]));
        }

        break;
      }
      case 'checklocktimeverify': {
        // OP_CHECKLOCKTIMEVERIFY = OP_NOP2
        if (!(flags & constants.flags.VERIFY_CHECKLOCKTIMEVERIFY)) {
          if (flags & constants.flags.VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
            return false;
          break;
        }

        if (!tx || stack.length === 0)
          return false;

        locktime = stack[stack.length - 1];

        if (!Buffer.isBuffer(locktime))
          return false;

        // NOTE: Bitcoind accepts 5 byte locktimes.
        // 4 byte locktimes become useless in 2106
        // (will people still be using bcoin then?).
        locktime = script.num(locktime, flags, 4).toNumber();

        if (locktime < 0)
          return false;

        threshold = constants.locktimeThreshold;
        if (!(
          (tx.locktime < threshold && locktime < threshold)
          || (tx.locktime >= threshold && locktime >= threshold)
        )) {
          return false;
        }

        if (locktime > tx.locktime)
          return false;

        if (tx.inputs[index].sequence === 0xffffffff)
          return false;

        break;
      }
      case 'checksequenceverify': {
        // OP_CHECKSEQUENCEVERIFY = OP_NOP3
        if (!(flags & constants.flags.VERIFY_CHECKSEQUENCEVERIFY)) {
          if (flags & constants.flags.VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
            return false;
          break;
        }

        if (!tx || stack.length === 0)
          return false;

        locktime = stack[stack.length - 1];

        if (!Buffer.isBuffer(locktime))
          return false;

        // NOTE: Bitcoind accepts 5 byte locktimes.
        // 4 byte locktimes become useless in 2106
        // (will people still be using bcoin then?).
        locktime = script.num(locktime, flags, 4).toNumber();

        if (locktime < 0)
          return false;

        if ((locktime & constants.sequenceLocktimeDisableFlag) !== 0)
          break;

        if (!script.checkSequence(locktime, tx, index))
          return false;

        break;
      }
      default: {
        // Unknown operation
        utils.debug('Unknown opcode "%s" at offset %d', o, pc);
        return false;
      }
    }
  }

  if (stack.length + stack.alt.length > constants.script.maxStack)
    return false;

  return true;
};

script.checkSequence = function checkSequence(sequence, tx, i) {
  var txSequence = tx.inputs[i].sequence;
  var locktimeMask, txSequenceMasked, sequenceMasked;

  if (tx.version < 2)
    return false;

  if (txSequence & constants.sequenceLocktimeDisableFlag)
    return false;

  locktimeMask = constants.sequenceLocktimeTypeFlag
    | constants.sequenceLocktimeMask;
  txSequenceMasked = txSequence & locktimeMask;
  sequenceMasked = sequence & locktimeMask;

  if (!(
    (txSequenceMasked < constants.sequenceLocktimeTypeFlag
    && sequenceMasked < constants.sequenceLocktimeTypeFlag)
    || (txSequenceMasked >= constants.sequenceLocktimeTypeFlag
    && sequenceMasked >= constants.sequenceLocktimeTypeFlag)
  )) {
    return false;
  }

  if (sequenceMasked > txSequenceMasked)
    return false;

  return true;
};

script.bool = function bool(value) {
  var i;

  // Should never happen:
  // if (typeof value === 'boolean')
  //   return value;

  // Should never happen:
  // if (utils.isFinite(value))
  //   return value !== 0;

  if (value instanceof bn)
    return value.cmpn(0) !== 0;

  assert(Buffer.isBuffer(value));

  for (i = 0; i < value.length; i++) {
    if (value[i] !== 0) {
      // Cannot be negative zero
      if (i === value.length - 1 && value[i] === 0x80)
        return false;
      return true;
    }
  }

  return false;
};

script.num = function num(value, flags, size) {
  assert(Buffer.isBuffer(value));

  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (size == null)
    size = 4;

  if (value.length > size)
    throw new Error('Script number overflow.');

  if ((flags & constants.flags.VERIFY_MINIMALDATA) && value.length > 0) {
    // If the low bits on the last byte are unset,
    // fail if the value's second to last byte does
    // not have the high bit set. A number can't
    // justify having the last byte's low bits unset
    // unless they ran out of space for the sign bit
    // in the second to last bit. We also fail on [0]
    // to avoid negative zero (also avoids positive
    // zero).
    if (!(value[value.length - 1] & 0x7f)) {
      if (value.length === 1 || !(value[value.length - 2] & 0x80))
        throw new Error('Non-minimally encoded script number.');
    }
  }

  // If we are signed, do (~num + 1) to get
  // the positive counterpart and set bn's
  // negative flag.
  if (value[value.length - 1] & 0x80) {
    if (utils.isNegZero(value, 'le')) {
      value = new bn(0, 'le');
    } else {
      value = new bn(value, 'le');
      value = value.notn(value.bitLength()).addn(1).neg();
    }
  } else {
    value = new bn(value, 'le');
  }

  return value;
};

script.array = function(value) {
  if (Buffer.isBuffer(value))
    return value;

  if (utils.isFinite(value))
    value = new bn(value, 'le');

  assert(value instanceof bn);

  // Convert the number to the
  // negative byte representation.
  if (value.isNeg()) {
    if (value.cmpn(0) === 0)
      value = new bn(0);
    else
      value = value.neg().notn(value.bitLength()).subn(1);
  }

  if (value.cmpn(0) === 0)
    return new Buffer([]);

  return new Buffer(value.toArray('le'));
};

script.removeData = function removeData(s, data) {
  for (var i = s.length - 1; i >= 0; i--) {
    if (utils.isEqual(s[i], data))
      s.splice(i, 1);
  }
};

script.checkPush = function checkPush(value, flags) {
  var op;

  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (!(flags & constants.flags.VERIFY_MINIMALDATA))
    return true;

  if (!value.pushdata)
    return true;

  op = value.pushdata.opcode

  if (!op)
    op = value.pushdata.len;

  if (value.length === 1 && value[0] === 0)
    return false;

  if (value.length === 1 && value[0] >= 1 && value[0] <= 16)
    return false;

  if (value.length === 1 && value[0] === 0xff)
    return false;

  if (value.length <= 75)
    return op === value.length;

  if (value.length <= 255)
    return op === 'pushdata1';

  if (value.length <= 65535)
    return op === 'pushdata2';

  return true;
};

script.createPubkey = function createPubkey(key) {
  return [key, 'checksig'];
};

script.createPubkeyhash = function createPubkeyhash(hash) {
  return [
    'dup',
    'hash160',
    hash,
    'equalverify',
    'checksig'
  ];
};

script.createMultisig = function createMultisig(keys, m, n) {
  if (keys.length !== n)
    throw new Error(n + ' keys are required to generate multisig script');

  assert(m >= 1 && m <= n);
  assert(n >= 1 && n <= 15);

  return [m].concat(
    utils.sortKeys(keys),
    [n, 'checkmultisig']
  );
};

script.createScripthash = function createScripthash(hash) {
  return [
    'hash160',
    hash,
    'equal'
  ];
};

script.createNulldata = function createNulldata(flags) {
  return [
    'return',
    flags
  ];
};

script.getRedeem = function getRedeem(s) {
  var raw, redeem;

  raw = s[s.length - 1];

  if (!Buffer.isBuffer(raw))
    return;

  if (raw._redeem)
    return raw._redeem;

  redeem = script.decode(raw);

  utils.hidden(redeem, '_raw', raw);
  utils.hidden(raw, '_redeem', redeem);

  return redeem;
};

script.getType =
script.getOutputType = function getOutputType(s) {
  var program;

  if (script.isCommitment(s))
    return 'commitment';

  if (script.isWitnessProgram(s)) {
    if (script.isWitnessPubkeyhash(s))
      return 'witnesspubkeyhash';
    if (script.isWitnessScripthash(s))
      return 'witnessscripthash';
    return 'unknown';
  }

  return (script.isPubkey(s) && 'pubkey')
    || (script.isPubkeyhash(s) && 'pubkeyhash')
    || (script.isMultisig(s) && 'multisig')
    || (script.isScripthash(s) && 'scripthash')
    || (script.isNulldata(s) && 'nulldata')
    || 'unknown';
};

script.isStandard = function isStandard(s) {
  var type = script.getType(s);
  var m, n;

  if (type === 'multisig') {
    m = s[0];
    n = s[s.length - 2];

    if (n < 1 || n > 3)
      return false;

    if (m < 1 || m > n)
      return false;
  } else if (type === 'nulldata') {
    if (script.getSize(s) > constants.script.maxOpReturnBytes)
      return false;
  }

  return type !== 'unknown';
};

script.getSize = function getSize(s) {
  if (s._raw)
    return s._raw.length;
  return script.encode(s).length;
};

// Legacy
script.size = script.getSize;

script.isScript = function isScript(s) {
  var i, b;

  if (!s)
    return false;

  if (!Buffer.isBuffer(s))
    return false;

  s = script.decode(s);

  for (i = 0; i < s.length; i++) {
    b = s[i];
    if (Buffer.isBuffer(b))
      continue;
    if (constants.opcodes[b] == null)
      return false;
  }

  return true;
};

script._locktime = function _locktime(s) {
  if (s.length < 2)
    return;

  if (!Buffer.isBuffer(s[0]))
    return;

  if (s[1] !== 'checklocktimeverify')
    return;

  return s[0];
};

script.isLocktime = function isLocktime(s) {
  return script._locktime(s) != null;
};

script.getLocktime = function getLocktime(s) {
  var locktime = script._locktime(s);

  if (!locktime)
    return;

  try {
    locktime = script.num(locktime, null, 4).toNumber();
  } catch (e) {
    locktime = 0;
  }

  if (locktime < constants.locktimeThreshold)
    return { type: 'height', value: locktime };

  return { type: 'time', value: locktime };
};

script.getInputData = function getData(s, prev) {
  var output, type;

  if (prev) {
    output = script.getOutputData(prev);
    output.side = 'input';

    // We could call _getInputData, but
    // we really only need the signatures.
    if (output.type === 'pubkey') {
      if (s.length >= 1)
        output.signatures = [s[0] === 0 ? new Buffer([]) : s[0]];
    } else if (output.type === 'pubkeyhash') {
      if (s.length >= 2) {
        output.signatures = [s[0] === 0 ? new Buffer([]) : s[0]];
        output.keys = [s[1]];
      }
    } else if (output.type === 'multisig') {
      if (s.length >= 2) {
        output.signatures = s.slice(1).map(function(sig) {
          return sig === 0 ? new Buffer([]) : sig;
        });
      }
    } else if (output.type === 'scripthash') {
      // Scripthash is the only case where
      // we get more data from the input
      // than the output.
      output = script._getInputData(s, output.type);
    } else {
      output.signatures = script.getUnknownData(s).signatures;
    }

    return output;
  }

  if (script.isPubkeyInput(s))
    type = 'pubkey';
  else if (script.isPubkeyhashInput(s))
    type = 'pubkeyhash';
  else if (script.isMultisigInput(s))
    type = 'multisig';
  else if (script.isScripthashInput(s))
    type = 'scripthash';
  else
    type = 'unknown';

  return script._getInputData(s, type);
};

script._getInputData = function _getInputData(s, type) {
  var sig, key, hash, raw, redeem, locktime, hash, address, input, output;

  assert(typeof type === 'string');

  if (s.length === 0) {
    return {
      type: 'unknown',
      side: 'input',
      none: true
    };
  }

  if (type === 'pubkey') {
    sig = s[0];
    if (sig === 0)
      sig = new Buffer([]);
    return {
      type: 'pubkey',
      side: 'input',
      signatures: [sig],
      none: true
    };
  }

  if (type === 'pubkeyhash') {
    sig = s[0];
    if (sig === 0)
      sig = new Buffer([]);
    key = s[1];
    hash = bcoin.address.hash160(key);
    address = bcoin.address.compileHash(hash, 'pubkeyhash');
    return {
      type: 'pubkeyhash',
      side: 'input',
      signatures: [sig],
      keys: [key],
      hashes: [hash],
      address: address,
      addresses: [address]
    };
  }

  if (type === 'multisig') {
    sig = s.slice(1).map(function(sig) {
      return sig === 0 ? new Buffer([]) : sig;
    });
    return {
      type: 'multisig',
      side: 'input',
      signatures: sig,
      m: sig.length,
      none: true
    };
  }

  if (type === 'scripthash') {
    raw = s[s.length - 1];
    redeem = script.decode(raw);
    locktime = script.getLocktime(redeem);
    hash = bcoin.address.hash160(raw);
    address = bcoin.address.compileHash(hash, 'scripthash');
    output = script.getOutputData(redeem, true);
    input = script._getInputData(s.slice(0, -1), output.type);
    delete input.none;
    return utils.merge(input, output, {
      type: 'scripthash',
      side: 'input',
      subtype: output.type,
      redeem: redeem,
      address: address,
      scriptHash: hash,
      scriptAddress: address,
      locktime: locktime
    });
  }

  return script.getUnknownData(s);
};

script.getOutputData = function getOutputData(s, inScriptHash) {
  var key, hash, address, mhash, maddress;

  if (script.isPubkey(s)) {
    key = s[0];
    hash = bcoin.address.hash160(key);
    // Convert p2pk to p2pkh addresses
    address = bcoin.address.compileHash(hash, 'pubkeyhash');
    return {
      type: 'pubkey',
      side: 'output',
      keys: [key],
      hashes: [hash],
      address: address,
      addresses: [address]
    };
  }

  if (script.isPubkeyhash(s)) {
    hash = s[2];
    address = bcoin.address.compileHash(hash, 'pubkeyhash');
    return {
      type: 'pubkeyhash',
      side: 'output',
      hashes: [hash],
      address: address,
      addresses: [address]
    };
  }

  if (script.isMultisig(s)) {
    key = s.slice(1, -2);
    hash = key.map(function(key) {
      return bcoin.address.hash160(key);
    });
    // Convert bare multisig to p2pkh addresses
    address = hash.map(function(hash) {
      return bcoin.address.compileHash(hash, 'pubkeyhash');
    });
    // Convert bare multisig script to scripthash address
    if (!inScriptHash) {
      mhash = bcoin.address.hash160(s._raw || script.encode(s));
      maddress = bcoin.address.compileHash(mhash, 'scripthash');
    }
    return {
      type: 'multisig',
      side: 'output',
      keys: key,
      hashes: hash,
      address: maddress,
      addresses: address,
      m: s[0],
      n: s[s.length - 2]
    };
  }

  if (script.isScripthash(s)) {
    hash = s[1];
    address = bcoin.address.compileHash(hash, 'scripthash');
    return {
      type: 'scripthash',
      side: 'output',
      address: address,
      scriptHash: hash,
      scriptAddress: address
    };
  }

  if (script.isNulldata(s)) {
    return {
      type: 'nulldata',
      side: 'output',
      nulldata: s[1],
      text: s[1].toString('utf8')
    };
  }

  return script.getUnknownData(s);
};

script.getUnknownData = function getUnknownData(s) {
  var sig = [];
  var key = [];
  var hash, address, i;

  for (i = 0; i < s.length; i++) {
    if (script.isSignatureEncoding(s[i]))
      sig.push(s[i]);
    else if (script.isKeyEncoding(s[i]))
      key.push(s[i]);
  }

  hash = key.map(function(key) {
    return bcoin.address.hash160(key);
  });

  address = hash.map(function(hash) {
    return bcoin.address.compileHash(hash, 'pubkeyhash');
  });

  return {
    type: 'unknown',
    signatures: sig,
    keys: key,
    hashes: hash,
    addresses: address,
    none: key.length === 0
  };
};

script.getInputAddress = function getInputAddress(s, prev, isWitness) {
  if (prev)
    return script.getOutputAddress(prev);

  if (script.isPubkeyInput(s))
    return;

  if (script.isPubkeyhashInput(s)) {
    return bcoin.address.compileData(s[1],
      isWitness ? 'witnesspubkeyhash' : 'pubkeyhash');
  }

  if (script.isMultisigInput(s))
    return;

  if (script.isScripthashInput(s)) {
    return bcoin.address.compileData(s[s.length - 1],
      isWitness ? 'witnessscripthash' : 'scripthash');
  }
};

script.getOutputAddress = function getOutputAddress(s) {
  var program;

  if (script.isWitnessProgram(s)) {
    program = script.getWitnessProgram(s);
    if (!program.type || program.type === 'unknown')
      return;
    return bcoin.address.compileHash(program.data, program.type);
  }

  // Convert p2pk to p2pkh addresses
  if (script.isPubkey(s))
    return bcoin.address.compileData(s[0], 'pubkeyhash');

  if (script.isPubkeyhash(s))
    return bcoin.address.compileHash(s[2], 'pubkeyhash')

  // Convert bare multisig to scripthash address
  if (script.isMultisig(s)) {
    s = s._raw || script.encode(s);
    return bcoin.address.compileData(s, 'scripthash');
  }

  if (script.isScripthash(s))
    return bcoin.address.compileHash(s[1], 'scripthash');
};

script.isPubkey = function isPubkey(s, key) {
  var res;

  if (s.length !== 2)
    return false;

  res = script.isKey(s[0]) && s[1] === 'checksig';

  if (!res)
    return false;

  if (key) {
    if (!utils.isEqual(s[0], key))
      return false;
  }

  return true;
};

script.isPubkeyhash = function isPubkeyhash(s, hash) {
  var res;

  if (s.length !== 5)
    return false;

  res = s[0] === 'dup'
    && s[1] === 'hash160'
    && script.isHash(s[2])
    && s[3] === 'equalverify'
    && s[4] === 'checksig';

  if (!res)
    return false;

  if (hash) {
    if (!utils.isEqual(s[2], hash))
      return false;
  }

  return true;
};

script.isMultisig = function isMultisig(s, keys) {
  var m, n, i, j;
  var total = 0;

  if (s.length < 4)
    return false;

  if (s[s.length - 1] !== 'checkmultisig')
    return false;

  n = s[s.length - 2];

  if (Buffer.isBuffer(n)) {
    if (n.length !== 0)
      return false;
    n = 0;
  }

  if (typeof n !== 'number')
    return false;

  // Bitcoind technically doesn't check for the
  // 15 limit here. It just counts the sigops
  // later.
  if (!(n >= 1 && n <= 15))
    return false;

  m = s[0];

  if (Buffer.isBuffer(m)) {
    if (m.length !== 0)
      return false;
    m = 0;
  }

  if (typeof m !== 'number')
    return false;

  if (!(m >= 1 && m <= n))
    return false;

  if (n + 3 !== s.length)
    return false;

  for (i = 1; i < n + 1; i++) {
    if (!script.isKey(s[i]))
      return false;
  }

  if (keys) {
    for (i = 1; i < n + 1; i++) {
      for (j = 0; j < keys.length; j++) {
        if (utils.isEqual(s[i], keys[j])) {
          total++;
          break;
        }
      }
    }

    if (total !== n)
      return false;
  }

  return true;
};

script.isScripthash = function isScripthash(s, hash) {
  var res;

  if (s.length !== 3)
    return false;

  res = s[0] === 'hash160'
    && script.isHash(s[1])
    && s[2] === 'equal';

  if (!res)
    return false;

  if (hash) {
    if (!utils.isEqual(s[1], hash))
      return false;
  }

  return true;
};

script.isNulldata = function isNulldata(s) {
  var res;

  if (s.length !== 2)
    return false;

  res = s[0] === 'return' && script.isData(s[1]);

  if (!res)
    return false;

  return true;
};

script.isCommitment = function isCommitment(s) {
  return s.length >= 2
    && s[0] === 'return'
    && Buffer.isBuffer(s[1])
    && s[1].length === 36
    && utils.readU32BE(s[1], 0) === 0xaa21a9ed;
};

script.getCommitmentHash = function getCommitmentHash(s) {
  if (!script.isCommitment(s))
    return;

  return s[1].slice(4, 36);
};

script.isWitnessProgram = function isWitnessProgram(s) {
  if (s.length !== 2)
    return false;

  if (typeof s[0] !== 'number')
    return false;

  if (!Buffer.isBuffer(s[1]))
    return false;

  return s[0] >= 0 && s[0] <= 16
    && s[1].length >= 2 && s[1].length <= 32;
};

script.getWitnessProgram = function getWitnessProgram(s) {
  var version, data, type;

  if (!script.isWitnessProgram(s))
    return;

  version = s[0];
  data = s[1];

  if (version > 0) {
    // No interpretation of script (anyone can spend)
    type = 'unknown';
  } else if (version === 0 && data.length === 20) {
    type = 'witnesspubkeyhash';
  } else if (version === 0 && data.length === 32) {
    type = 'witnessscripthash';
  } else {
    // Fail on bad version=0
    type = null;
  }

  return {
    version: version,
    type: type,
    data: data
  };
};

script.isWitnessPubkeyhash = function isWitnessPubkeyhash(s) {
  if (!script.isWitnessProgram(s))
    return false;

  return s[0] === 0 && s[1].length === 20;
};

script.isWitnessScripthash = function isWitnessScripthash(s) {
  if (!script.isWitnessProgram(s))
    return false;

  return s[0] === 0 && s[1].length === 32;
};

script.createWitnessProgram = function createWitnessProgram(version, data) {
  assert(typeof version === 'number' && version >= 0 && version <= 16);
  assert(Buffer.isBuffer(data));
  assert(data.length === 20 || data.length === 32);
  return [version, data];
};

script.getInputType = function getInputType(s, prev, isWitness) {
  var type;

  if (prev)
    return script.getOutputType(prev);

  type = (script.isPubkeyInput(s) && 'pubkey')
    || (script.isPubkeyhashInput(s) && 'pubkeyhash')
    || (script.isMultisigInput(s) && 'multisig')
    || (script.isScripthashInput(s) && 'scripthash')
    || 'unknown';

  if (isWitness) {
    if (type === 'pubkeyhash')
      return 'witnesspubkeyhash';
    if (type === 'scripthash')
      return 'witnessscripthash';
    return 'unknown';
  }

  return type;
};

script.isPubkeyInput = function isPubkeyInput(s, key) {
  if (s.length !== 1)
    return false;

  if (!script.isSignature(s[0]))
    return false;

  assert(!key);

  return true;
};

script.isPubkeyhashInput = function isPubkeyhashInput(s, key) {
  if (s.length !== 2)
    return false;

  if (!script.isSignature(s[0]))
    return false;

  if (!script.isKey(s[1]))
    return false;

  if (key) {
    if (!utils.isEqual(s[1], key))
      return false;
  }

  return true;
};

script.isMultisigInput = function isMultisigInput(s, keys) {
  var i;

  // We need to rule out scripthash because
  // it may look like multisig. This is
  // strange because it's technically a
  // recursive call.
  if (script.isScripthashInput(s))
    return false;

  if (s.length < 3)
    return false;

  if (s[0] !== 0 && !script.isDummy(s[0]))
    return false;

  for (i = 1; i < s.length; i++) {
    if (!script.isSignature(s[i]))
      return false;
  }

  assert(!keys);

  return true;
};

script.isScripthashInput = function isScripthashInput(s, redeem) {
  var raw;

  // Grab the raw redeem script.
  raw = s[s.length - 1];

  // Need at least one data element with
  // the redeem script. NOTE: NOT THE CASE FOR SEGWIT!
  // if (s.length < 2)
  if (s.length < 1)
    return false;

  // Last data element should be an array
  // for the redeem script.
  if (!Buffer.isBuffer(raw))
    return false;

  // Check data against last array in case
  // a raw redeem script was passed in.
  if (redeem)
    return utils.isEqual(redeem, raw);

  // Testing for scripthash inputs requires
  // some evil magic to work. We do it by
  // ruling things _out_. This test will not
  // be correct 100% of the time. We rule
  // out that the last data element is: a
  // null dummy, a valid signature, a valid
  // key, and we ensure that it is at least
  // a script that does not use undefined
  // opcodes.
  if (script.isDummy(raw))
    return false;

  if (script.isSignatureEncoding(raw))
    return false;

  if (script.isKeyEncoding(raw))
    return false;

  if (!script.isScript(raw))
    return false;

  return true;
};

script.getCoinbaseData = function getCoinbaseData(s) {
  var coinbase, flags;

  coinbase = {
    script: s
  };

  if (Buffer.isBuffer(s[0]) && s[0].length <= 6) {
    coinbase.height = new bn(s[0], 'le').toNumber();
  } else {
    coinbase.height = -1;
  }

  if (Buffer.isBuffer(s[1]))
    coinbase.extraNonce = new bn(s[1], 'le');
  else
    coinbase.extraNonce = new bn(0, 'le');

  flags = s.slice(2).filter(function(chunk) {
    return Buffer.isBuffer(chunk) && chunk.length !== 0;
  });

  coinbase.flags = flags;
  coinbase.text =
    flags.map(function(flag) {
      return flag.toString('utf8');
    }).join('')
    .replace(/[\u0000-\u0019\u007f-\u00ff]/g, '');

  return coinbase;
};

// Detect script array types. Note: these functions
// are not mutually exclusive. Only use for
// verification, not detection.

script.isHash = function isHash(hash) {
  if (!Buffer.isBuffer(hash))
    return false;

  return hash.length === 20;
};

script.isKey = function isKey(key) {
  if (!Buffer.isBuffer(key))
    return false;

  return key.length >= 33 && key.length <= 65;
};

script.isSignature = function isSignature(sig) {
  if (!Buffer.isBuffer(sig))
    return false;

  return sig.length >= 9 && sig.length <= 73;
};

script.isDummy = function isDummy(data) {
  if (!Buffer.isBuffer(data))
    return false;

  return data.length === 0;
};

script.isZero = function isZero(data) {
  if (data === 0)
    return true;

  return script.isDummy(data);
};

script.isData = function isData(data) {
  if (!Buffer.isBuffer(data))
    return false;

  return data.length <= constants.script.maxOpReturn;
};

script.isValidKey = function isValidKey(key, flags) {
  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (!Buffer.isBuffer(key))
    return false;

  if (flags & constants.flags.VERIFY_STRICTENC) {
    if (!script.isKeyEncoding(key)) {
      utils.debug('Script failed key encoding test.');
      return false;
    }
  }

  return true;
};

script.isKeyEncoding = function isKeyEncoding(key) {
  if (!Buffer.isBuffer(key))
    return false;

  if (key.length < 33)
    return false;

  if (key[0] === 0x04) {
    if (key.length !== 65)
      return false;
  } else if (key[0] === 0x02 || key[0] === 0x03) {
    if (key.length !== 33)
      return false;
  } else {
    return false;
  }

  return true;
};

script.isValidSignature = function isValidSignature(sig, flags) {
  if (flags == null)
    flags = constants.flags.STANDARD_VERIFY_FLAGS;

  if (!Buffer.isBuffer(sig))
    return false;

  // Allow empty sigs
  if (sig.length === 0)
    return true;

  if ((flags & constants.flags.VERIFY_DERSIG)
      || (flags & constants.flags.VERIFY_LOW_S)
      || (flags & constants.flags.VERIFY_STRICTENC)) {
    if (!script.isSignatureEncoding(sig)) {
      utils.debug('Script does not have a proper signature encoding.');
      return false;
    }
  }

  if (flags & constants.flags.VERIFY_LOW_S) {
    if (!script.isLowDER(sig)) {
      utils.debug('Script does not have a low DER.');
      return false;
    }
  }

  if (flags & constants.flags.VERIFY_STRICTENC) {
    if (!script.isHashType(sig)) {
      utils.debug('Script does not have a valid hash type.');
      return false;
    }
  }

  return true;
};

// https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki
/**
 * A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
 * Where R and S are not negative (their first byte has its highest bit not set), and not
 * excessively padded (do not start with a 0 byte, unless an otherwise negative number follows,
 * in which case a single 0 byte is necessary and even required).
 *
 * See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
 *
 * This function is consensus-critical since BIP66.
 */
script.isSignatureEncoding = function isSignatureEncoding(sig) {
  var lenR, lenS;

  if (!Buffer.isBuffer(sig))
    return false;

  // Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
  // * total-length: 1-byte length descriptor of everything that follows,
  //   excluding the sighash byte.
  // * R-length: 1-byte length descriptor of the R value that follows.
  // * R: arbitrary-length big-endian encoded R value. It must use the shortest
  //   possible encoding for a positive integers (which means no null bytes at
  //   the start, except a single one when the next byte has its highest bit set).
  // * S-length: 1-byte length descriptor of the S value that follows.
  // * S: arbitrary-length big-endian encoded S value. The same rules apply.
  // * sighash: 1-byte value indicating what data is hashed (not part of the DER
  //   signature)

  // Minimum and maximum size constraints.
  if (sig.length < 9)
    return false;

  if (sig.length > 73)
    return false;

  // A signature is of type 0x30 (compound).
  if (sig[0] !== 0x30)
    return false;

  // Make sure the length covers the entire signature.
  if (sig[1] !== sig.length - 3)
    return false;

  // Extract the length of the R element.
  lenR = sig[3];

  // Make sure the length of the S element is still inside the signature.
  if (5 + lenR >= sig.length)
    return false;

  // Extract the length of the S element.
  lenS = sig[5 + lenR];

  // Verify that the length of the signature matches the sum of the length
  // of the elements.
  if (lenR + lenS + 7 !== sig.length)
    return false;

  // Check whether the R element is an integer.
  if (sig[2] !== 0x02)
    return false;

  // Zero-length integers are not allowed for R.
  if (lenR === 0)
    return false;

  // Negative numbers are not allowed for R.
  if (sig[4] & 0x80)
    return false;

  // Null bytes at the start of R are not allowed, unless R would
  // otherwise be interpreted as a negative number.
  if (lenR > 1 && (sig[4] === 0x00) && !(sig[5] & 0x80))
    return false;

  // Check whether the S element is an integer.
  if (sig[lenR + 4] !== 0x02)
    return false;

  // Zero-length integers are not allowed for S.
  if (lenS === 0)
    return false;

  // Negative numbers are not allowed for S.
  if (sig[lenR + 6] & 0x80)
    return false;

  // Null bytes at the start of S are not allowed, unless S would otherwise be
  // interpreted as a negative number.
  if (lenS > 1 && (sig[lenR + 6] === 0x00) && !(sig[lenR + 7] & 0x80))
    return false;

  return true;
};

script.isHashType = function isHashType(sig) {
  if (!Buffer.isBuffer(sig))
    return false;

  if (sig.length === 0)
    return false;

  type = sig[sig.length - 1] & ~constants.hashType.anyonecanpay;

  if (!constants.hashTypeByVal[type])
    return false;

  return true;
};

script.isLowDER = function isLowDER(sig) {
  if (!sig.s) {
    if (!Buffer.isBuffer(sig))
      return false;

    if (!script.isSignatureEncoding(sig))
      return false;

    sig = sig.slice(0, -1);
  }

  return bcoin.ec.isLowS(sig);
};

script.format = function format(s) {
  var scripts = [];

  if (Array.isArray(s)) {
    scripts.push(s);
  } else if (s instanceof bcoin.input) {
    scripts.push(s.script);
    if (s.output) {
      scripts.push(s.output.script);
      if (script.isScripthash(s.output.script))
        scripts.push(script.getRedeem(s.script));
    }
  } else if (s instanceof bcoin.output) {
    scripts.push(s.script);
  }

  return script.concat(scripts).map(function(chunk) {
    if (Buffer.isBuffer(chunk))
      return '[' + utils.toHex(chunk) + ']';

    if (typeof chunk === 'number')
      return chunk + '';

    return chunk;
  }).join(' ');
};

script.isPushOnly = function isPushOnly(s) {
  var i, op;
  for (i = 0; i < s.length; i++) {
    op = s[i];
    if (Buffer.isBuffer(op) || op === '1negate' || (op >= 0 && op <= 16))
      continue;
    return false;
  }
  return true;
};

script.getSigops = function getSigops(s, accurate) {
  var i, op;
  var total = 0;
  var lastOp = -1;

  for (i = 0; i < s.length; i++) {
    op = s[i];

    if (Buffer.isBuffer(op))
      continue;

    if (constants.opcodes[op] == null)
      return 0;

    if (op === 'checksig' || op === 'checksigverify') {
      total++;
    } else if (op === 'checkmultisig' || op === 'checkmultisigverify') {
      if (accurate && lastOp >= 1 && lastOp <= 16)
        total += lastOp;
      else
        total += constants.script.maxPubkeysPerMultisig;
    }

    lastOp = op;
  }

  return total;
};

script.getArgs = function getArgs(s) {
  var keys, m;

  if (script.isPubkey(s))
    return 1;

  if (script.isPubkeyhash(s))
    return 2;

  if (script.isMultisig(s)) {
    keys = s.slice(1, -2);
    m = s[0];
    if (keys.length < 1 || m < 1)
      return -1;
    return m + 1;
  }

  if (script.isScripthash(s))
    return 1;

  if (script.isNulldata(s))
    return -1;

  if (script.isWitnessScripthash(s))
    return 1;

  if (script.isWitnessPubkeyhash(s))
    return 2;

  return -1;
};