Inside Bitcoin

251OP_NOP7 = CScriptOp(0xb6)
252OP_NOP8 = CScriptOp(0xb7)
253OP_NOP9 = CScriptOp(0xb8)
254OP_NOP10 = CScriptOp(0xb9)
255
256# BIP 342 opcodes (Tapscript)
257OP_CHECKSIGADD = CScriptOp(0xba)
258
259OP_INVALIDOPCODE = CScriptOp(0xff)
260
261OPCODE_NAMES.update({
262    OP_0: 'OP_0',
263    OP_PUSHDATA1: 'OP_PUSHDATA1',
264    OP_PUSHDATA2: 'OP_PUSHDATA2',
265    OP_PUSHDATA4: 'OP_PUSHDATA4',
266    OP_1NEGATE: 'OP_1NEGATE',
267    OP_RESERVED: 'OP_RESERVED',
268    OP_1: 'OP_1',
269    OP_2: 'OP_2',
270    OP_3: 'OP_3',
271    OP_4: 'OP_4',
272    OP_5: 'OP_5',
273    OP_6: 'OP_6',
274    OP_7: 'OP_7',
275    OP_8: 'OP_8',
276    OP_9: 'OP_9',
277    OP_10: 'OP_10',
278    OP_11: 'OP_11',
279    OP_12: 'OP_12',
280    OP_13: 'OP_13',
281    OP_14: 'OP_14',
282    OP_15: 'OP_15',
283    OP_16: 'OP_16',
284    OP_NOP: 'OP_NOP',
285    OP_VER: 'OP_VER',
286    OP_IF: 'OP_IF',
287    OP_NOTIF: 'OP_NOTIF',
288    OP_VERIF: 'OP_VERIF',
289    OP_VERNOTIF: 'OP_VERNOTIF',
290    OP_ELSE: 'OP_ELSE',
291    OP_ENDIF: 'OP_ENDIF',
292    OP_VERIFY: 'OP_VERIFY',
293    OP_RETURN: 'OP_RETURN',
294    OP_TOALTSTACK: 'OP_TOALTSTACK',
295    OP_FROMALTSTACK: 'OP_FROMALTSTACK',
296    OP_2DROP: 'OP_2DROP',
297    OP_2DUP: 'OP_2DUP',
298    OP_3DUP: 'OP_3DUP',
299    OP_2OVER: 'OP_2OVER',
300    OP_2ROT: 'OP_2ROT',
301    OP_2SWAP: 'OP_2SWAP',
302    OP_IFDUP: 'OP_IFDUP',
303    OP_DEPTH: 'OP_DEPTH',
304    OP_DROP: 'OP_DROP',
305    OP_DUP: 'OP_DUP',
306    OP_NIP: 'OP_NIP',
307    OP_OVER: 'OP_OVER',
308    OP_PICK: 'OP_PICK',
309    OP_ROLL: 'OP_ROLL',
310    OP_ROT: 'OP_ROT',
311    OP_SWAP: 'OP_SWAP',
312    OP_TUCK: 'OP_TUCK',
313    OP_CAT: 'OP_CAT',
314    OP_SUBSTR: 'OP_SUBSTR',
315    OP_LEFT: 'OP_LEFT',
316    OP_RIGHT: 'OP_RIGHT',
317    OP_SIZE: 'OP_SIZE',
318    OP_INVERT: 'OP_INVERT',
319    OP_AND: 'OP_AND',
320    OP_OR: 'OP_OR',
321    OP_XOR: 'OP_XOR',
322    OP_EQUAL: 'OP_EQUAL',
323    OP_EQUALVERIFY: 'OP_EQUALVERIFY',
324    OP_RESERVED1: 'OP_RESERVED1',
325    OP_RESERVED2: 'OP_RESERVED2',
326    OP_1ADD: 'OP_1ADD',
327    OP_1SUB: 'OP_1SUB',
328    OP_2MUL: 'OP_2MUL',
329    OP_2DIV: 'OP_2DIV',
330    OP_NEGATE: 'OP_NEGATE',
331    OP_ABS: 'OP_ABS',
332    OP_NOT: 'OP_NOT',
333    OP_0NOTEQUAL: 'OP_0NOTEQUAL',
334    OP_ADD: 'OP_ADD',
335    OP_SUB: 'OP_SUB',
336    OP_MUL: 'OP_MUL',
337    OP_DIV: 'OP_DIV',
338    OP_MOD: 'OP_MOD',
339    OP_LSHIFT: 'OP_LSHIFT',
340    OP_RSHIFT: 'OP_RSHIFT',
341    OP_BOOLAND: 'OP_BOOLAND',
342    OP_BOOLOR: 'OP_BOOLOR',
343    OP_NUMEQUAL: 'OP_NUMEQUAL',
344    OP_NUMEQUALVERIFY: 'OP_NUMEQUALVERIFY',
345    OP_NUMNOTEQUAL: 'OP_NUMNOTEQUAL',
346    OP_LESSTHAN: 'OP_LESSTHAN',
347    OP_GREATERTHAN: 'OP_GREATERTHAN',
348    OP_LESSTHANOREQUAL: 'OP_LESSTHANOREQUAL',
349    OP_GREATERTHANOREQUAL: 'OP_GREATERTHANOREQUAL',
350    OP_MIN: 'OP_MIN',
351    OP_MAX: 'OP_MAX',
352    OP_WITHIN: 'OP_WITHIN',
353    OP_RIPEMD160: 'OP_RIPEMD160',
354    OP_SHA1: 'OP_SHA1',
355    OP_SHA256: 'OP_SHA256',
356    OP_HASH160: 'OP_HASH160',
357    OP_HASH256: 'OP_HASH256',
358    OP_CODESEPARATOR: 'OP_CODESEPARATOR',
359    OP_CHECKSIG: 'OP_CHECKSIG',
360    OP_CHECKSIGVERIFY: 'OP_CHECKSIGVERIFY',
361    OP_CHECKMULTISIG: 'OP_CHECKMULTISIG',
362    OP_CHECKMULTISIGVERIFY: 'OP_CHECKMULTISIGVERIFY',
363    OP_NOP1: 'OP_NOP1',
364    OP_CHECKLOCKTIMEVERIFY: 'OP_CHECKLOCKTIMEVERIFY',
365    OP_CHECKSEQUENCEVERIFY: 'OP_CHECKSEQUENCEVERIFY',
366    OP_NOP4: 'OP_NOP4',
367    OP_NOP5: 'OP_NOP5',
368    OP_NOP6: 'OP_NOP6',
369    OP_NOP7: 'OP_NOP7',
370    OP_NOP8: 'OP_NOP8',
371    OP_NOP9: 'OP_NOP9',
372    OP_NOP10: 'OP_NOP10',
373    OP_CHECKSIGADD: 'OP_CHECKSIGADD',
374    OP_INVALIDOPCODE: 'OP_INVALIDOPCODE',
375})
376
377class CScriptInvalidError(Exception):
378    """Base class for CScript exceptions"""
379    pass
380
381class CScriptTruncatedPushDataError(CScriptInvalidError):
382    """Invalid pushdata due to truncation"""
383    def __init__(self, msg, data):
384        self.data = data
385        super().__init__(msg)
386
387
388# This is used, eg, for blockchain heights in coinbase scripts (bip34)
389class CScriptNum:
390    __slots__ = ("value",)
391
392    def __init__(self, d=0):
393        self.value = d
394
395    @staticmethod
396    def encode(obj):
397        r = bytearray(0)
398        if obj.value == 0:
399            return bytes(r)
400        neg = obj.value < 0
401        absvalue = -obj.value if neg else obj.value
402        while (absvalue):
403            r.append(absvalue & 0xff)
404            absvalue >>= 8
405        if r[-1] & 0x80:
406            r.append(0x80 if neg else 0)
407        elif neg:
408            r[-1] |= 0x80
409        return bytes([len(r)]) + r
410
411    @staticmethod
412    def decode(vch):
413        result = 0
414        # We assume valid push_size and minimal encoding
415        value = vch[1:]
416        if len(value) == 0:
417            return result
418        for i, byte in enumerate(value):
419            result |= int(byte) << 8 * i
420        if value[-1] >= 0x80:
421            # Mask for all but the highest result bit
422            num_mask = (2**(len(value) * 8) - 1) >> 1
423            result &= num_mask
424            result *= -1
425        return result
426
427
428class CScript(bytes):
429    """Serialized script
430
431    A bytes subclass, so you can use this directly whenever bytes are accepted.
432    Note that this means that indexing does *not* work - you'll get an index by
433    byte rather than opcode. This format was chosen for efficiency so that the
434    general case would not require creating a lot of little CScriptOP objects.
435
436    iter(script) however does iterate by opcode.
437    """
438    __slots__ = ()
439
440    @classmethod
441    def __coerce_instance(cls, other):
442        # Coerce other into bytes
443        if isinstance(other, CScriptOp):
444            other = bytes([other])
445        elif isinstance(other, CScriptNum):
446            if (other.value == 0):
447                other = bytes([CScriptOp(OP_0)])
448            else:
449                other = CScriptNum.encode(other)
450        elif isinstance(other, int):
451            if 0 <= other <= 16:
452                other = bytes([CScriptOp.encode_op_n(other)])
453            elif other == -1:
454                other = bytes([OP_1NEGATE])
455            else:
456                other = CScriptOp.encode_op_pushdata(bn2vch(other))
457        elif isinstance(other, (bytes, bytearray)):
458            other = CScriptOp.encode_op_pushdata(other)
459        return other
460
461    def __add__(self, other):
462        # add makes no sense for a CScript()
463        raise NotImplementedError
464
465    def join(self, iterable):
466        # join makes no sense for a CScript()
467        raise NotImplementedError
468
469    def __new__(cls, value=b''):
470        if isinstance(value, bytes) or isinstance(value, bytearray):
471            return super().__new__(cls, value)
472        else:
473            def coerce_iterable(iterable):
474                for instance in iterable:
475                    yield cls.__coerce_instance(instance)
476            # Annoyingly on both python2 and python3 bytes.join() always
477            # returns a bytes instance even when subclassed.
478            return super().__new__(cls, b''.join(coerce_iterable(value)))
479
480    def raw_iter(self):
481        """Raw iteration
482
483        Yields tuples of (opcode, data, sop_idx) so that the different possible
484        PUSHDATA encodings can be accurately distinguished, as well as
485        determining the exact opcode byte indexes. (sop_idx)
486        """
487        i = 0
488        while i < len(self):
489            sop_idx = i
490            opcode = CScriptOp(self[i])
491            i += 1
492
493            if opcode > OP_PUSHDATA4:
494                yield (opcode, None, sop_idx)
495            else:
496                datasize = None
497                pushdata_type = None
498                if opcode < OP_PUSHDATA1:
499                    pushdata_type = 'PUSHDATA(%d)' % opcode
500                    datasize = opcode