blockchain-parser-2 0.1.6__py3-none-any.whl

blockchain_parser/transaction.py

@@ -0,0 +1,196 @@
+# Copyright (C) 2015-2016 The bitcoin-blockchain-parser developers
+#
+# This file is part of bitcoin-blockchain-parser.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of bitcoin-blockchain-parser, including this file, may be copied,
+# modified, propagated, or distributed except according to the terms contained
+# in the LICENSE file.
+
+from math import ceil
+
+from .utils import decode_compactsize, decode_uint32, double_sha256, format_hash
+from .input import Input
+from .output import Output
+
+
+def bip69_sort(data):
+    return list(sorted(data, key=lambda t: (t[0], t[1])))
+
+
+class Transaction(object):
+    """Represents a bitcoin transaction"""
+
+    def __init__(self, raw_hex):
+        self._hash = None
+        self._txid = None
+        self.inputs = None
+        self.outputs = None
+        self._version = None
+        self._locktime = None
+        self._size = None
+        self.n_inputs = 0
+        self.n_outputs = 0
+        self.is_segwit = False
+
+        offset = 4
+
+        # adds basic support for segwit transactions
+        #   - https://bitcoincore.org/en/segwit_wallet_dev/
+        #   - https://en.bitcoin.it/wiki/Protocol_documentation#BlockTransactions
+        if b'\x00\x01' == raw_hex[offset:offset + 2]:
+            self.is_segwit = True
+            offset += 2
+
+        self.n_inputs, varint_size = decode_compactsize(raw_hex[offset:])
+        offset += varint_size
+
+        self.inputs = []
+        for i in range(self.n_inputs):
+            input = Input.from_hex(raw_hex[offset:])
+            offset += input.size
+            self.inputs.append(input)
+
+        self.n_outputs, varint_size = decode_compactsize(raw_hex[offset:])
+        offset += varint_size
+
+        self.outputs = []
+        for i in range(self.n_outputs):
+            output = Output.from_hex(raw_hex[offset:])
+            offset += output.size
+            self.outputs.append(output)
+
+        if self.is_segwit:
+            self._offset_before_tx_witnesses = offset
+            for inp in self.inputs:
+                tx_witnesses_n, varint_size = decode_compactsize(raw_hex[offset:])
+                offset += varint_size
+                for j in range(tx_witnesses_n):
+                    component_length, varint_size = decode_compactsize(
+                        raw_hex[offset:])
+                    offset += varint_size
+                    witness = raw_hex[offset:offset + component_length]
+                    inp.add_witness(witness)
+                    offset += component_length
+
+        self._size = offset + 4
+        self.hex = raw_hex[:self._size]
+
+        if self._size != len(self.hex):
+            raise Exception("Incomplete transaction!")
+
+    def __repr__(self):
+        return "Transaction(%s)" % self.hash
+
+    @classmethod
+    def from_hex(cls, hex):
+        return cls(hex)
+
+    @property
+    def version(self):
+        """Returns the transaction's version number"""
+        if self._version is None:
+            self._version = decode_uint32(self.hex[:4])
+        return self._version
+
+    @property
+    def locktime(self):
+        """Returns the transaction's locktime as an int"""
+        if self._locktime is None:
+            self._locktime = decode_uint32(self.hex[-4:])
+        return self._locktime
+
+    @property
+    def hash(self):
+        """Returns the transaction's id. Equivalent to the hash for non SegWit transactions,
+        it differs from it for SegWit ones. """
+        if self._hash is None:
+            self._hash = format_hash(double_sha256(self.hex))
+
+        return self._hash
+
+    @property
+    def size(self):
+        """Returns the transactions size in bytes including the size of the
+        witness data if there is any."""
+        return self._size
+
+    @property
+    def vsize(self):
+        """Returns the transaction size in virtual bytes."""
+        if not self.is_segwit:
+            return self._size
+        else:
+            # the witness is the last element in a transaction before the
+            # 4 byte locktime and self._offset_before_tx_witnesses is the
+            # position where the witness starts
+            witness_size = self._size - self._offset_before_tx_witnesses - 4
+
+            # size of the transaction without the segwit marker (2 bytes) and
+            # the witness
+            stripped_size = self._size - (2 + witness_size)
+            weight = stripped_size * 3 + self._size
+
+            # vsize is weight / 4 rounded up
+            return ceil(weight / 4)
+
+    @property
+    def txid(self):
+        """Returns the transaction's id. Equivalent to the hash for non SegWit transactions,
+        it differs from it for SegWit ones. """
+        if self._txid is None:
+            # segwit transactions have two transaction ids/hashes, txid and wtxid
+            # txid is a hash of all of the legacy transaction fields only
+            if self.is_segwit:
+                txid_data = self.hex[:4] + self.hex[
+                                           6:self._offset_before_tx_witnesses] + self.hex[
+                                                                                 -4:]
+            else:
+                txid_data = self.hex
+            self._txid = format_hash(double_sha256(txid_data))
+
+        return self._txid
+
+    def is_coinbase(self):
+        """Returns whether the transaction is a coinbase transaction"""
+        for input in self.inputs:
+            if input.transaction_hash == "0" * 64:
+                return True
+        return False
+
+    def uses_replace_by_fee(self):
+        """Returns whether the transaction opted-in for RBF"""
+        # Coinbase transactions may have a sequence number that signals RBF
+        # but they cannot use it as it's only enforced for non-coinbase txs
+        if self.is_coinbase():
+            return False
+
+        # A transactions opts-in for RBF when having an input
+        # with a sequence number < MAX_INT - 1
+        for input in self.inputs:
+            if input.sequence_number < 4294967294:
+                return True
+        return False
+
+    def uses_bip69(self):
+        """Returns whether the transaction complies to BIP-69,
+        lexicographical ordering of inputs and outputs"""
+        # Quick check
+        if self.n_inputs == 1 and self.n_outputs == 1:
+            return True
+
+        # BIP69 compares previous outpoints in display byte order, then index.
+        input_keys = [
+            (i.hex[:32][::-1], i.transaction_index)
+            for i in self.inputs
+        ]
+
+        if bip69_sort(input_keys) != input_keys:
+            return False
+
+        # Output scripts are compared as raw scriptPubKey bytes.
+        output_keys = [(o.value, o.script.hex) for o in self.outputs]
+
+        return bip69_sort(output_keys) == output_keys

blockchain_parser/undo.py

@@ -0,0 +1,198 @@
+# Copyright (C) 2015-2020 The bitcoin-blockchain-parser developers
+#
+# This file is part of bitcoin-blockchain-parser.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of bitcoin-blockchain-parser, including this file, may be copied,
+# modified, propagated, or distributed except according to the terms contained
+# in the LICENSE file.
+
+from .script import Script
+from .utils import decode_varint, decode_compactsize, decompress_txout_amt
+
+_SECP256K1_P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+_NSPECIAL_SCRIPTS = 6
+
+
+def _decompress_pubkey(prefix, x_bytes):
+    """Recover the uncompressed SEC pubkey from a compressed x coordinate."""
+    if prefix not in (2, 3) or len(x_bytes) != 32:
+        raise ValueError("invalid compressed pubkey")
+    x = int.from_bytes(x_bytes, "big")
+    if x >= _SECP256K1_P:
+        raise ValueError("pubkey x coordinate is out of range")
+    y_squared = (pow(x, 3, _SECP256K1_P) + 7) % _SECP256K1_P
+    y = pow(y_squared, (_SECP256K1_P + 1) // 4, _SECP256K1_P)
+    if pow(y, 2, _SECP256K1_P) != y_squared:
+        raise ValueError("pubkey x coordinate is not on the curve")
+    if (y & 1) != (prefix & 1):
+        y = _SECP256K1_P - y
+    return b"\x04" + x_bytes + y.to_bytes(32, "big")
+
+
+def decompress_script(raw_hex):
+    """Return scriptPubKey bytes stored in Bitcoin Core's compressed form.
+
+    The encoding is the one in bitcoin/src/compressor.cpp. Special types
+    0 and 1 are 20-byte hashes, types 2 and 3 are compressed pubkeys, types
+    4 and 5 are x-only coordinates of uncompressed pubkeys, and every larger
+    size code is ``len(script) + 6`` followed by the raw script.
+    """
+    if not raw_hex:
+        raise ValueError("empty compressed script")
+    script_type, type_len = decode_varint(raw_hex)
+    payload = raw_hex[type_len:]
+
+    if script_type == 0:
+        if len(payload) < 20:
+            raise ValueError("Compressed script has wrong size")
+        program = payload[:20]
+        return b"\x76\xa9\x14" + program + b"\x88\xac"
+    if script_type == 1:
+        if len(payload) < 20:
+            raise ValueError("Compressed script has wrong size")
+        program = payload[:20]
+        return b"\xa9\x14" + program + b"\x87"
+    if script_type in (2, 3):
+        if len(payload) < 32:
+            raise ValueError("Compressed script has wrong size")
+        pubkey = bytes([script_type]) + payload[:32]
+        return bytes([33]) + pubkey + b"\xac"
+    if script_type in (4, 5):
+        if len(payload) < 32:
+            raise ValueError("Compressed script has wrong size")
+        pubkey = _decompress_pubkey(script_type - 2, payload[:32])
+        return bytes([65]) + pubkey + b"\xac"
+    if script_type < _NSPECIAL_SCRIPTS:
+        raise ValueError("unknown compressed script type")
+    script_len = script_type - _NSPECIAL_SCRIPTS
+    if len(payload) < script_len:
+        raise ValueError("Compressed script has wrong size")
+    return payload[:script_len]
+
+
+def _script_from_compressed(raw_hex):
+    return Script.from_hex(decompress_script(raw_hex))
+
+
+class BlockUndo(object):
+    """
+    Represents a block of spent transaction outputs (coins), as encoded 
+    in the undo rev*.dat files
+    """
+    def __init__(self, raw_hex):
+        self._raw_hex = raw_hex
+        self.spends = []
+        num_txs, pos = decode_compactsize(raw_hex)
+        # print("found %d" % num_txs + " transactions")
+        for i in range(num_txs):
+            # print("calling SpentOutput with raw_hex %s", raw_hex)
+            txn = SpentTransaction(raw_hex=raw_hex[pos:])
+            self.spends.append(txn)
+            # print("found transaction #%d length %d hex: " % (i, txn.len), raw_hex[pos:pos+txn.len].hex())
+            pos += txn.len
+
+
+class SpentTransaction(object):
+    """Represents the script portion of a spent Transaction output"""
+    def __init__(self, raw_hex=None):
+        self._raw_hex = raw_hex
+        self.outputs = []
+        # print("decoding compactsize for hex: ",  raw_hex.hex())
+        self.output_len, pos = decode_compactsize(raw_hex)
+        # print("found %d" % self.output_len + " outputs")
+        for i in range(self.output_len):
+            output = SpentOutput(raw_hex=raw_hex[pos:])
+            self.outputs.append(output)
+            # print("found output #%d length %d hex: " % (i, output.len), raw_hex[pos:pos+output.len].hex())
+            pos += output.len
+        self.len = pos
+
+    @classmethod
+    def from_hex(cls, hex_):
+        return cls(hex_)
+
+
+class SpentOutput(object):
+    """Represents a spent Transaction output"""
+
+    def __init__(self, raw_hex=None):
+        self._raw_hex = raw_hex
+        self._script = None
+        pos = 0
+
+        # decode height code
+        height_code, height_code_len = decode_varint(raw_hex[pos:])
+        if height_code % 2 == 1:
+            self.is_coinbase = True
+            height_code -= 1
+        else:
+            self.is_coinbase = False
+        self.height = height_code // 2
+
+        # Bitcoin Core writes a compatibility byte only when height > 0.
+        pos = height_code_len
+        if self.height > 0:
+            pos += 1
+
+        # decode compressed txout amount
+        compressed_amt, compressed_amt_len = decode_varint(raw_hex[pos:])
+        self.amt = decompress_txout_amt(compressed_amt)
+        pos += compressed_amt_len
+
+        # get script
+        script_hex, script_len = SpentScriptPubKey.extract_from_hex(raw_hex[pos:])
+        self.script_pub_key_compressed = SpentScriptPubKey(script_hex)
+        self.len = pos + script_len
+
+    @classmethod
+    def from_hex(cls, hex_):
+        return cls(hex_)
+
+    
+    @property
+    def script(self):
+        if self._script is None:
+            raw_hex = self.script_pub_key_compressed._raw_hex
+            self._script = _script_from_compressed(raw_hex)
+        return self._script
+
+
+
+class SpentScriptPubKey(object):
+    """Represents the script portion of a spent Transaction output"""
+    def __init__(self, raw_hex=None):
+        self._raw_hex = raw_hex
+        self._script = None
+        self.len = len(raw_hex)
+
+    @classmethod
+    def from_hex(cls, hex_):
+        return cls(hex_)
+
+    @classmethod
+    def extract_from_hex(cls, raw_hex):
+        """Return the compressed script bytes and the number of bytes consumed."""
+        if not raw_hex:
+            raise ValueError("empty compressed script")
+        if raw_hex[0] in (0x00, 0x01):
+            size = 21
+        elif raw_hex[0] in (0x02, 0x03, 0x04, 0x05):
+            size = 33
+        else:
+            script_len_code, script_len_code_len = decode_varint(raw_hex)
+            real_script_len = script_len_code - _NSPECIAL_SCRIPTS
+            size = script_len_code_len + real_script_len
+            if real_script_len < 0:
+                raise ValueError("invalid compressed script size")
+        if size > len(raw_hex):
+            raise ValueError("Compressed script has wrong size")
+        return (raw_hex[:size], size)
+
+    @property
+    def script(self):
+        if self._script is None:
+            self._script = _script_from_compressed(self._raw_hex)
+        return self._script

blockchain_parser/utils.py

@@ -0,0 +1,152 @@
+# Copyright (C) 2015-2016 The bitcoin-blockchain-parser developers
+#
+# This file is part of bitcoin-blockchain-parser.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of bitcoin-blockchain-parser, including this file, may be copied,
+# modified, propagated, or distributed except according to the terms contained
+# in the LICENSE file.
+
+import hashlib
+import struct
+
+try:
+    from ripemd import ripemd160 as _ripemd160
+except ImportError:
+    _ripemd160 = None
+
+def btc_ripemd160(data):
+    """Computes ripemd160(sha256(data))"""
+
+    hashed = hashlib.sha256(data).digest()
+    if _ripemd160 is not None:
+        digest = _ripemd160.new()
+        digest.update(hashed)
+        return digest.digest()
+    return hashlib.new("ripemd160", hashed).digest()
+
+
+def double_sha256(data):
+    return hashlib.sha256(hashlib.sha256(data).digest()).digest()
+
+
+def format_hash(hash_):
+    return hash_[::-1].hex()
+
+
+def decode_uint32(data):
+    assert(len(data) == 4)
+    return struct.unpack("<I", data)[0]
+
+
+def decode_uint64(data):
+    assert(len(data) == 8)
+    return struct.unpack("<Q", data)[0]
+
+
+def decode_compactsize(data):
+    assert(len(data) > 0)
+    size = int(data[0])
+    assert(size <= 255)
+
+    if size < 253:
+        return size, 1
+
+    if size == 253:
+        format_ = '<H'
+    elif size == 254:
+        format_ = '<I'
+    elif size == 255:
+        format_ = '<Q'
+    else:
+        # Should never be reached
+        assert 0, "unknown format_ for size : %s" % size
+
+    size = struct.calcsize(format_)
+    return struct.unpack(format_, data[1:size+1])[0], size + 1
+
+
+def decode_varint(raw_hex):
+    """
+    Reads the weird format of VarInt present in src/serialize.h of bitcoin core
+    and being used for storing data in the leveldb.
+    This is not the VARINT format described for general bitcoin serialization
+    use.
+    """
+    n = 0
+    pos = 0
+    while True:
+        try:
+            data = raw_hex[pos]
+        except IndexError as e:
+            print("IndexError caught on raw_hex: ", raw_hex, e)
+            raise e
+        pos += 1
+        n = (n << 7) | (data & 0x7f)
+        if data & 0x80 == 0:
+            return n, pos
+        n += 1
+
+
+def decompress_txout_amt(amount_compressed_int):
+    # (this function stolen from https://github.com/sr-gi/bitcoin_tools and modified to remove bug)
+    # No need to do any work if it's zero.
+    if amount_compressed_int == 0:
+        return 0
+
+    # The decompressed amount is either of the following two equations:
+    # x = 1 + 10*(9*n + d - 1) + e
+    # x = 1 + 10*(n - 1)       + 9
+    amount_compressed_int -= 1
+
+    # The decompressed amount is now one of the following two equations:
+    # x = 10*(9*n + d - 1) + e
+    # x = 10*(n - 1)       + 9
+    exponent = amount_compressed_int % 10
+    
+    # integer division
+    amount_compressed_int //= 10
+
+    # The decompressed amount is now one of the following two equations:
+    # x = 9*n + d - 1  | where e < 9
+    # x = n - 1        | where e = 9
+    n = 0
+    if exponent < 9:
+        lastDigit = amount_compressed_int%9 + 1
+        # integer division
+        amount_compressed_int //= 9
+        n = amount_compressed_int*10 + lastDigit
+    else:
+        n = amount_compressed_int + 1
+
+    # Apply the exponent.
+    return n * 10**exponent
+
+
+def compress_txout_amt(n):
+    """ Compresses the Satoshi amount of a UTXO to be stored in the LevelDB. Code is a port from the Bitcoin Core C++
+    source:
+        https://github.com/bitcoin/bitcoin/blob/v0.13.2/src/compressor.cpp#L133#L160
+    :param n: Satoshi amount to be compressed.
+    :type n: int
+    :return: The compressed amount of Satoshis.
+    :rtype: int
+    (this function stolen from https://github.com/sr-gi/bitcoin_tools and modified to remove bug)
+    """
+
+    if n == 0:
+        return 0
+    e = 0
+    while ((n % 10) == 0) and e < 9:
+        n //= 10
+        e += 1
+
+    if e < 9:
+        d = (n % 10)
+        assert (1 <= d <= 9)
+        n //= 10
+        return 1 + (n * 9 + d - 1) * 10 + e
+    else:
+        return 1 + (n - 1) * 10 + 9

blockchain_parser/utils_taproot.py

@@ -0,0 +1,143 @@
+# Copyright (C) 2015-2016 The bitcoin-blockchain-parser developers
+#
+# This file is part of bitcoin-blockchain-parser.
+#
+# It is subject to the license terms in the LICENSE file found in the top-level
+# directory of this distribution.
+#
+# No part of bitcoin-blockchain-parser, including this file, may be copied,
+# modified, propagated, or distributed except according to the terms contained
+# in the LICENSE file.
+#
+# Encoding/Decoding written by Pieter Wuille (2017)
+# and adapted by Anton Wahrstätter (2022)
+# https://github.com/Bytom/python-bytomlib/blob/master/pybtmsdk/segwit_addr.py
+
+from enum import Enum
+
+
+class Encoding(Enum):
+    """Enumeration type to list the various supported encodings."""
+    BECH32 = 1
+    BECH32M = 2
+
+
+CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+BECH32M_CONST = 0x2bc830a3
+
+
+def bech32_polymod(values):
+    """Internal function that computes the Bech32 checksum."""
+    generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+    chk = 1
+    for value in values:
+        top = chk >> 25
+        chk = (chk & 0x1ffffff) << 5 ^ value
+        for i in range(5):
+            chk ^= generator[i] if ((top >> i) & 1) else 0
+    return chk
+
+
+def bech32_hrp_expand(hrp):
+    """Expand the HRP into values for checksum computation."""
+    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
+
+
+def bech32_verify_checksum(hrp, data):
+    """Verify a checksum given HRP and converted data characters."""
+    const = bech32_polymod(bech32_hrp_expand(hrp) + data)
+    if const == 1:
+        return Encoding.BECH32
+    if const == BECH32M_CONST:
+        return Encoding.BECH32M
+    return None
+
+
+def bech32_create_checksum(hrp, data, spec):
+    """Compute the checksum values given HRP and data."""
+    values = bech32_hrp_expand(hrp) + data
+    const = BECH32M_CONST if spec == Encoding.BECH32M else 1
+    polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ const
+    return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
+
+
+def bech32_encode(hrp, data, spec):
+    """Compute a Bech32 string given HRP and data values."""
+    combined = data + bech32_create_checksum(hrp, data, spec)
+    return hrp + '1' + ''.join([CHARSET[d] for d in combined])
+
+
+def bech32_decode(bech):
+    """Validate a Bech32/Bech32m string, and determine HRP and data."""
+    if ((any(ord(x) < 33 or ord(x) > 126 for x in bech)) or
+            (bech.lower() != bech and bech.upper() != bech)):
+        return (None, None, None)
+    bech = bech.lower()
+    pos = bech.rfind('1')
+    if pos < 1 or pos + 7 > len(bech) or len(bech) > 90:
+        return (None, None, None)
+    if not all(x in CHARSET for x in bech[pos+1:]):
+        return (None, None, None)
+    hrp = bech[:pos]
+    data = [CHARSET.find(x) for x in bech[pos+1:]]
+    spec = bech32_verify_checksum(hrp, data)
+    if spec is None:
+        return (None, None, None)
+    return (hrp, data[:-6], spec)
+
+
+def convertbits(data, frombits, tobits, pad=True):
+    """General power-of-2 base conversion."""
+    acc = 0
+    bits = 0
+    ret = []
+    maxv = (1 << tobits) - 1
+    max_acc = (1 << (frombits + tobits - 1)) - 1
+    for value in data:
+        if value < 0 or (value >> frombits):
+            return None
+        acc = ((acc << frombits) | value) & max_acc
+        bits += frombits
+        while bits >= tobits:
+            bits -= tobits
+            ret.append((acc >> bits) & maxv)
+    if pad:
+        if bits:
+            ret.append((acc << (tobits - bits)) & maxv)
+    elif bits >= frombits or ((acc << (tobits - bits)) & maxv):
+        return None
+    return ret
+
+
+def decode(hrp, addr):
+    """Decode a segwit address."""
+    hrpgot, data, spec = bech32_decode(addr)
+    if hrpgot != hrp:
+        return (None, None)
+    decoded = convertbits(data[1:], 5, 8, False)
+    if decoded is None or len(decoded) < 2 or len(decoded) > 40:
+        return (None, None)
+    if data[0] > 16:
+        return (None, None)
+    if data[0] == 0 and len(decoded) != 20 and len(decoded) != 32:
+        return (None, None)
+    if data[0] == 0 and spec != Encoding.BECH32 \
+        or data[0] != 0 and spec != Encoding.BECH32M:
+            return (None, None)
+    return (data[0], decoded)
+
+
+def encode(witprog):
+    hrp, witver = "bc", 1
+    """Encode a segwit address."""
+    spec = Encoding.BECH32M
+    ret = bech32_encode(hrp, [witver] + convertbits(witprog, 8, 5), spec)
+    if decode(hrp, ret) == (None, None):
+        return None
+    return ret
+
+
+def from_taproot(tpk):
+    """Input Tweaked Public Key."""
+    tpk = [int(tpk[i:i+2], 16) for i in range(0, len(tpk), 2)]
+    return encode(tpk)