"""A single script opcode"""

__slots__ = []

@staticmethod

def encode_op_pushdata(d):

"""Encode a PUSHDATA op, returning bytes"""

if len(d) < 0x4c:

return b'' + bchr(len(d)) + d # OP_PUSHDATA

elif len(d) <= 0xff:

return b'\x4c' + bchr(len(d)) + d # OP_PUSHDATA1

elif len(d) <= 0xffff:

return b'\x4d' + struct.pack(b'<H', len(d)) + d # OP_PUSHDATA2

elif len(d) <= 0xffffffff:

return b'\x4e' + struct.pack(b'<I', len(d)) + d # OP_PUSHDATA4

else:

raise ValueError("Data too long to encode in a PUSHDATA op")

@staticmethod

def encode_op_n(n):

"""Encode a small integer op, returning an opcode"""

if not (0 <= n <= 16):

raise ValueError('Integer must be in range 0 <= n <= 16, got %d' % n)

if n == 0:

return OP_0

else:

return CScriptOp(OP_1 + n-1)

def decode_op_n(self):

"""Decode a small integer opcode, returning an integer"""

if self == OP_0:

return 0

if not (self == OP_0 or OP_1 <= self <= OP_16):

raise ValueError('op %r is not an OP_N' % self)

return int(self - OP_1+1)

def is_small_int(self):

"""Return true if the op pushes a small integer to the stack"""

if 0x51 <= self <= 0x60 or self == 0:

return True

else:

return False

def __str__(self):

return repr(self)

def __repr__(self):

if self in OPCODE_NAMES:

return OPCODE_NAMES[self]

else:

return 'CScriptOp(0x%x)' % self

def __new__(cls, n):

try:

return _opcode_instances[n]

except IndexError:

assert len(_opcode_instances) == n

_opcode_instances.append(super(CScriptOp, cls).__new__(cls, n))

OP_1NEGATE,

OP_RESERVED,

OP_1,

OP_2,

OP_3,

OP_4,

OP_5,

OP_6,

OP_7,

OP_8,

OP_9,

OP_10,

OP_11,

OP_12,

OP_13,

OP_14,

OP_15,

OP_16,

OP_NOP,

OP_VER,

OP_IF,

OP_NOTIF,

OP_VERIF,

OP_VERNOTIF,

OP_ELSE,

OP_ENDIF,

OP_VERIFY,

OP_RETURN,

OP_TOALTSTACK,

OP_FROMALTSTACK,

OP_2DROP,

OP_2DUP,

OP_3DUP,

OP_2OVER,

OP_2ROT,

OP_2SWAP,

OP_IFDUP,

OP_DEPTH,

OP_DROP,

OP_DUP,

OP_NIP,

OP_OVER,

OP_PICK,

OP_ROLL,

OP_ROT,

OP_SWAP,

OP_TUCK,

OP_CAT,

OP_SUBSTR,

OP_LEFT,

OP_RIGHT,

OP_SIZE,

OP_INVERT,

OP_AND,

OP_OR,

OP_XOR,

OP_EQUAL,

OP_EQUALVERIFY,

OP_RESERVED1,

OP_RESERVED2,

OP_1ADD,

OP_1SUB,

OP_2MUL,

OP_2DIV,

OP_NEGATE,

OP_ABS,

OP_NOT,

OP_0NOTEQUAL,

OP_ADD,

OP_SUB,

OP_MUL,

OP_DIV,

OP_MOD,

OP_LSHIFT,

OP_RSHIFT,

OP_BOOLAND,

OP_BOOLOR,

OP_NUMEQUAL,

OP_NUMEQUALVERIFY,

OP_NUMNOTEQUAL,

OP_LESSTHAN,

OP_GREATERTHAN,

OP_LESSTHANOREQUAL,

OP_GREATERTHANOREQUAL,

OP_MIN,

OP_MAX,

OP_WITHIN,

OP_RIPEMD160,

OP_SHA1,

OP_SHA256,

OP_HASH160,

OP_HASH256,

OP_CODESEPARATOR,

OP_CHECKSIG,

OP_CHECKSIGVERIFY,

OP_CHECKMULTISIG,

OP_CHECKMULTISIGVERIFY,

OP_NOP1,

OP_CHECKLOCKTIMEVERIFY,

OP_CHECKSEQUENCEVERIFY,

OP_NOP4,

OP_NOP5,

OP_NOP6,

OP_NOP7,

OP_NOP8,

OP_NOP9,

OP_NOP10,

OP_SWAPSTACK,

OP_CHECKSIGFROMSTACKVERIFY,

OP_SMALLINTEGER,

OP_PUBKEYS,

OP_PUBKEYHASH,

OP_PUBKEY,

'OP_0' : OP_0,

'OP_PUSHDATA1' : OP_PUSHDATA1,

'OP_PUSHDATA2' : OP_PUSHDATA2,

'OP_PUSHDATA4' : OP_PUSHDATA4,

'OP_1NEGATE' : OP_1NEGATE,

'OP_RESERVED' : OP_RESERVED,

'OP_1' : OP_1,

'OP_2' : OP_2,

'OP_3' : OP_3,

'OP_4' : OP_4,

'OP_5' : OP_5,

'OP_6' : OP_6,

'OP_7' : OP_7,

'OP_8' : OP_8,

'OP_9' : OP_9,

'OP_10' : OP_10,

'OP_11' : OP_11,

'OP_12' : OP_12,

'OP_13' : OP_13,

'OP_14' : OP_14,

'OP_15' : OP_15,

'OP_16' : OP_16,

'OP_NOP' : OP_NOP,

'OP_VER' : OP_VER,

'OP_IF' : OP_IF,

'OP_NOTIF' : OP_NOTIF,

'OP_VERIF' : OP_VERIF,

'OP_VERNOTIF' : OP_VERNOTIF,

'OP_ELSE' : OP_ELSE,

'OP_ENDIF' : OP_ENDIF,

'OP_VERIFY' : OP_VERIFY,

'OP_RETURN' : OP_RETURN,

'OP_TOALTSTACK' : OP_TOALTSTACK,

'OP_FROMALTSTACK' : OP_FROMALTSTACK,

'OP_2DROP' : OP_2DROP,

'OP_2DUP' : OP_2DUP,

'OP_3DUP' : OP_3DUP,

'OP_2OVER' : OP_2OVER,

'OP_2ROT' : OP_2ROT,

'OP_2SWAP' : OP_2SWAP,

'OP_IFDUP' : OP_IFDUP,

'OP_DEPTH' : OP_DEPTH,

'OP_DROP' : OP_DROP,

'OP_DUP' : OP_DUP,

'OP_NIP' : OP_NIP,

'OP_OVER' : OP_OVER,

'OP_PICK' : OP_PICK,

'OP_ROLL' : OP_ROLL,

'OP_ROT' : OP_ROT,

'OP_SWAP' : OP_SWAP,

'OP_TUCK' : OP_TUCK,

'OP_CAT' : OP_CAT,

'OP_SUBSTR' : OP_SUBSTR,

'OP_LEFT' : OP_LEFT,

'OP_RIGHT' : OP_RIGHT,

'OP_SIZE' : OP_SIZE,

'OP_INVERT' : OP_INVERT,

'OP_AND' : OP_AND,

'OP_OR' : OP_OR,

'OP_XOR' : OP_XOR,

'OP_EQUAL' : OP_EQUAL,

'OP_EQUALVERIFY' : OP_EQUALVERIFY,

'OP_RESERVED1' : OP_RESERVED1,

'OP_RESERVED2' : OP_RESERVED2,

'OP_1ADD' : OP_1ADD,

'OP_1SUB' : OP_1SUB,

'OP_2MUL' : OP_2MUL,

'OP_2DIV' : OP_2DIV,

'OP_NEGATE' : OP_NEGATE,

'OP_ABS' : OP_ABS,

'OP_NOT' : OP_NOT,

'OP_0NOTEQUAL' : OP_0NOTEQUAL,

'OP_ADD' : OP_ADD,

'OP_SUB' : OP_SUB,

'OP_MUL' : OP_MUL,

'OP_DIV' : OP_DIV,

'OP_MOD' : OP_MOD,

'OP_LSHIFT' : OP_LSHIFT,

'OP_RSHIFT' : OP_RSHIFT,

'OP_BOOLAND' : OP_BOOLAND,

'OP_BOOLOR' : OP_BOOLOR,

'OP_NUMEQUAL' : OP_NUMEQUAL,

'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY,

'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL,

'OP_LESSTHAN' : OP_LESSTHAN,

'OP_GREATERTHAN' : OP_GREATERTHAN,

'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL,

'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL,

'OP_MIN' : OP_MIN,

'OP_MAX' : OP_MAX,

'OP_WITHIN' : OP_WITHIN,

'OP_RIPEMD160' : OP_RIPEMD160,

'OP_SHA1' : OP_SHA1,

'OP_SHA256' : OP_SHA256,

'OP_HASH160' : OP_HASH160,

'OP_HASH256' : OP_HASH256,

'OP_CODESEPARATOR' : OP_CODESEPARATOR,

'OP_CHECKSIG' : OP_CHECKSIG,

'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY,

'OP_CHECKMULTISIG' : OP_CHECKMULTISIG,

'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY,

'OP_NOP1' : OP_NOP1,

'OP_CHECKLOCKTIMEVERIFY' : OP_CHECKLOCKTIMEVERIFY,

'OP_CHECKSEQUENCEVERIFY' : OP_CHECKSEQUENCEVERIFY,

'OP_NOP4' : OP_NOP4,

'OP_NOP5' : OP_NOP5,

'OP_NOP6' : OP_NOP6,

'OP_NOP7' : OP_NOP7,

'OP_NOP8' : OP_NOP8,

'OP_NOP9' : OP_NOP9,

'OP_NOP10' : OP_NOP10,

'OP_SMALLINTEGER' : OP_SMALLINTEGER,

'OP_PUBKEYS' : OP_PUBKEYS,

'OP_PUBKEYHASH' : OP_PUBKEYHASH,

'OP_PUBKEY' : OP_PUBKEY,

"""Invalid pushdata due to truncation"""

def __init__(self, msg, data):

self.data = data

def __init__(self, d=0):

self.value = d

@staticmethod

def encode(obj):

r = bytearray(0)

if obj.value == 0:

return bytes(r)

neg = obj.value < 0

absvalue = -obj.value if neg else obj.value

while (absvalue):

r.append(absvalue & 0xff)

absvalue >>= 8

if r[-1] & 0x80:

r.append(0x80 if neg else 0)

elif neg:

r[-1] |= 0x80

"""Serialized script

A bytes subclass, so you can use this directly whenever bytes are accepted.

Note that this means that indexing does *not* work - you'll get an index by

byte rather than opcode. This format was chosen for efficiency so that the

general case would not require creating a lot of little CScriptOP objects.

iter(script) however does iterate by opcode.

"""

@classmethod

def __coerce_instance(cls, other):

# Coerce other into bytes

if isinstance(other, CScriptOp):

other = bchr(other)

elif isinstance(other, CScriptNum):

if (other.value == 0):

other = bchr(CScriptOp(OP_0))

else:

other = CScriptNum.encode(other)

elif isinstance(other, int):

if 0 <= other <= 16:

other = bytes(bchr(CScriptOp.encode_op_n(other)))

elif other == -1:

other = bytes(bchr(OP_1NEGATE))

else:

other = CScriptOp.encode_op_pushdata(bn2vch(other))

elif isinstance(other, (bytes, bytearray)):

other = CScriptOp.encode_op_pushdata(other)

return other

def __add__(self, other):

# Do the coercion outside of the try block so that errors in it are

# noticed.

other = self.__coerce_instance(other)

try:

# bytes.__add__ always returns bytes instances unfortunately

return CScript(super(CScript, self).__add__(other))

except TypeError:

raise TypeError('Can not add a %r instance to a CScript' % other.__class__)

def join(self, iterable):

# join makes no sense for a CScript()

raise NotImplementedError

def __new__(cls, value=b''):

if isinstance(value, bytes) or isinstance(value, bytearray):

return super(CScript, cls).__new__(cls, value)

else:

def coerce_iterable(iterable):

for instance in iterable:

yield cls.__coerce_instance(instance)

# Annoyingly on both python2 and python3 bytes.join() always

# returns a bytes instance even when subclassed.

return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value)))

def raw_iter(self):

"""Raw iteration

Yields tuples of (opcode, data, sop_idx) so that the different possible

PUSHDATA encodings can be accurately distinguished, as well as

determining the exact opcode byte indexes. (sop_idx)

"""

i = 0

while i < len(self):

sop_idx = i

opcode = bord(self[i])

i += 1

if opcode > OP_PUSHDATA4:

yield (opcode, None, sop_idx)

else:

datasize = None

pushdata_type = None

if opcode < OP_PUSHDATA1:

pushdata_type = 'PUSHDATA(%d)' % opcode

datasize = opcode

elif opcode == OP_PUSHDATA1:

pushdata_type = 'PUSHDATA1'

if i >= len(self):

raise CScriptInvalidError('PUSHDATA1: missing data length')

datasize = bord(self[i])

i += 1

elif opcode == OP_PUSHDATA2:

pushdata_type = 'PUSHDATA2'

if i + 1 >= len(self):

raise CScriptInvalidError('PUSHDATA2: missing data length')

datasize = bord(self[i]) + (bord(self[i+1]) << 8)

i += 2

elif opcode == OP_PUSHDATA4:

pushdata_type = 'PUSHDATA4'

if i + 3 >= len(self):

raise CScriptInvalidError('PUSHDATA4: missing data length')

datasize = bord(self[i]) + (bord(self[i+1]) << 8) + (bord(self[i+2]) << 16) + (bord(self[i+3]) << 24)

i += 4

else:

assert False # shouldn't happen

data = bytes(self[i:i+datasize])

# Check for truncation

if len(data) < datasize:

raise CScriptTruncatedPushDataError('%s: truncated data' % pushdata_type, data)

i += datasize

yield (opcode, data, sop_idx)

def __iter__(self):

"""'Cooked' iteration

Returns either a CScriptOP instance, an integer, or bytes, as

appropriate.

See raw_iter() if you need to distinguish the different possible

PUSHDATA encodings.

"""

for (opcode, data, sop_idx) in self.raw_iter():

if data is not None:

yield data

else:

opcode = CScriptOp(opcode)

if opcode.is_small_int():

yield opcode.decode_op_n()

else:

yield CScriptOp(opcode)

def __repr__(self):

# For Python3 compatibility add b before strings so testcases don't

# need to change

def _repr(o):

if isinstance(o, bytes):

return b"x('%s')" % hexlify(o).decode('ascii')

else:

return repr(o)

ops = []

i = iter(self)

while True:

op = None

try:

op = _repr(next(i))

except CScriptTruncatedPushDataError as err:

op = '%s...<ERROR: %s>' % (_repr(err.data), err)

break

except CScriptInvalidError as err:

op = '<ERROR: %s>' % err

break

except StopIteration:

break

finally:

if op is not None:

ops.append(op)

return "CScript([%s])" % ', '.join(ops)

def GetSigOpCount(self, fAccurate):

"""Get the SigOp count.

fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details.

Note that this is consensus-critical.

"""

n = 0

lastOpcode = OP_INVALIDOPCODE

for (opcode, data, sop_idx) in self.raw_iter():

if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY):

n += 1

elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY):

if fAccurate and (OP_1 <= lastOpcode <= OP_16):

n += opcode.decode_op_n()

else:

n += 20

lastOpcode = opcode

"""Consensus critical, see FindAndDelete() in Satoshi codebase"""

r = b''

last_sop_idx = sop_idx = 0

skip = True

for (opcode, data, sop_idx) in script.raw_iter():

if not skip:

r += script[last_sop_idx:sop_idx]

last_sop_idx = sop_idx

if script[sop_idx:sop_idx + len(sig)] == sig:

skip = True

else:

skip = False

if not skip:

r += script[last_sop_idx:]

"""Consensus-correct SignatureHash

Returns (hash, err) to precisely match the consensus-critical behavior of

the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)

"""

HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

if inIdx >= len(txTo.vin):

return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin)))

txtmp = CTransaction(txTo)

for txin in txtmp.vin:

txin.scriptSig = b''

txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR]))

if (hashtype & 0x1f) == SIGHASH_NONE:

txtmp.vout = []

for i in range(len(txtmp.vin)):

if i != inIdx:

txtmp.vin[i].nSequence = 0

elif (hashtype & 0x1f) == SIGHASH_SINGLE:

outIdx = inIdx

if outIdx >= len(txtmp.vout):

return (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))

tmp = txtmp.vout[outIdx]

txtmp.vout = []

for i in range(outIdx):

txtmp.vout.append(CTxOut(-1))

txtmp.vout.append(tmp)

for i in range(len(txtmp.vin)):

if i != inIdx:

txtmp.vin[i].nSequence = 0

if hashtype & SIGHASH_ANYONECANPAY:

tmp = txtmp.vin[inIdx]

txtmp.vin = []

txtmp.vin.append(tmp)

s = txtmp.serialize()

s += struct.pack(b"<I", hashtype)

hash = hash256(s)

hashPrevouts = 0

hashSequence = 0

hashOutputs = 0

if not (hashtype & SIGHASH_ANYONECANPAY):

serialize_prevouts = bytes()

for i in txTo.vin:

serialize_prevouts += i.prevout.serialize()

hashPrevouts = uint256_from_str(hash256(serialize_prevouts))

if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):

serialize_sequence = bytes()

for i in txTo.vin:

serialize_sequence += struct.pack("<I", i.nSequence)

hashSequence = uint256_from_str(hash256(serialize_sequence))

if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):

serialize_outputs = bytes()

for o in txTo.vout:

serialize_outputs += o.serialize()

hashOutputs = uint256_from_str(hash256(serialize_outputs))

elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)):

serialize_outputs = txTo.vout[inIdx].serialize()

hashOutputs = uint256_from_str(hash256(serialize_outputs))

ss = bytes()

ss += struct.pack("<i", txTo.nVersion)

ss += ser_uint256(hashPrevouts)

ss += ser_uint256(hashSequence)

ss += txTo.vin[inIdx].prevout.serialize()

ss += ser_string(script)

ss += struct.pack("<q", amount)

ss += struct.pack("<I", txTo.vin[inIdx].nSequence)

ss += ser_uint256(hashOutputs)

ss += struct.pack("<i", txTo.nLockTime)

ss += struct.pack("<I", hashtype)

assert (len(sigScriptCode) == 6)

hashPrevouts = 0

hashSequence = 0

hashOutputs = 0

nVersion = txTo.nVersion if (hashtype & SIGHASHV2_VERSION) else -1

nLockTime = txTo.nLockTime if (hashtype & SIGHASHV2_LOCKTIME) else 0xffffffff

nSequence = txTo.vin[inIdx].nSequence if (hashtype & SIGHASHV2_THISSEQUENCE) else 0xffffffff

hashScript = uint256_from_str(hashScriptIn) if (hashtype & SIGHASHV2_KEYSCRIPTHASH) else 0

fees = feesIn if (hashtype & SIGHASHV2_FEE) else -1

prevout = txTo.vin[inIdx].prevout if (hashtype & SIGHASHV2_THISINPUT) else COutPoint(0, 0xffffffff)

amount = amountIn if (hashtype & SIGHASHV2_THISINPUT) else -1

program = programIn if (hashtype & SIGHASHV2_THISINPUT) else CScript()

if (hashtype & SIGHASHV2_THISINPUT):

if ((hashtype & SIGHASHV2_ALLINPUT) == SIGHASHV2_ALLINPUT):

serialize_prevouts = bytes()

for i in txTo.vin:

serialize_prevouts += i.prevout.serialize()

hashPrevouts = uint256_from_str(hash256(serialize_prevouts))

if ((hashtype & SIGHASHV2_ALLINPUT_ALLSEQUENCE) == SIGHASHV2_ALLINPUT_ALLSEQUENCE):

serialize_sequence = bytes()

for i in txTo.vin:

serialize_sequence += struct.pack("<I", i.nSequence)

hashSequence = uint256_from_str(hash256(serialize_sequence))

elif ((hashtype & SIGHASHV2_INVALID) == SIGHASHV2_INVALID):