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

blockchain_parser/tests/test_index.py

@@ -0,0 +1,48 @@
+import unittest
+from binascii import a2b_hex
+
+from blockchain_parser.index import DBBlockIndex
+from blockchain_parser.index import DBTransactionIndex
+
+
+class TestDBIndex(unittest.TestCase):
+    def test_from_hex(self):
+        key_str = "0000000000000000169cdec8dcfa2e408f59e0d50b1a228f65d8f548" \
+                  "0f990000"
+        value_str = "88927193a7021d8160804aaa89fc0185b6e81e02000000fb759231" \
+                    "e1fa5f80c3508e3a59ebf301930257d04aa4920700000000000000" \
+                    "00c11c6bc67af8264be7979db45043f5f5c1e8d2060082af4ce795" \
+                    "7658a22147e30bf97f54747b1b187d1eac41"
+
+        value_hex = a2b_hex(value_str)
+        idx = DBBlockIndex(key_str, value_hex)
+
+        self.assertEqual(idx.hash, "0000000000000000169cdec8dcfa2e408f59e0d50"
+                                   "b1a228f65d8f5480f990000")
+        self.assertEqual(idx.height, 332802)
+        self.assertEqual(idx.status, 29)
+        self.assertEqual(idx.n_tx, 352)
+        self.assertEqual(idx.file, 202)
+        self.assertEqual(idx.data_pos, 90357377)
+        self.assertEqual(idx.undo_pos, 13497502)
+        self.assertEqual(idx.version, 2)
+        self.assertEqual(idx.nonce, 1101799037)
+        self.assertEqual(idx.prev_hash, "00000000000000000792a44ad057029301f3e"
+                                        "b593a8e50c3805ffae1319275fb")
+        self.assertEqual(idx.merkle_root, "e34721a2587695e74caf820006d2e8c1f5f"
+                                          "54350b49d97e74b26f87ac66b1cc1")
+
+
+class TestDBTransactionIndex(unittest.TestCase):
+    def test_from_hex(self):
+        key_str = "70ad7da56decc86b8a58ac53dbde792c9e97552cdaafd37312af7c4" \
+                  "d5c7d0cc1"
+        value_str = "9071938b980ba4bf39"
+
+        value_hex = a2b_hex(value_str)
+        idx = DBTransactionIndex(key_str, value_hex)
+
+        self.assertEqual(idx.hash, key_str)
+        self.assertEqual(idx.blockfile_no, 2289)
+        self.assertEqual(idx.block_offset, 614457)
+        self.assertEqual(idx.file_offset, 42142859)

blockchain_parser/tests/test_output.py

@@ -0,0 +1,66 @@
+# 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 unittest
+from binascii import a2b_hex
+
+from blockchain_parser.output import Output
+
+
+class TestOutput(unittest.TestCase):
+    def test_pubkeyhash_from_hex(self):
+        raw_output = "01000000000000001976a91432ba382cf668657bae15ee0a97fa87" \
+                     "f12e1bc89f88ac"
+        output = Output.from_hex(a2b_hex(raw_output))
+        self.assertTrue(output.is_pubkeyhash())
+        self.assertEqual("pubkeyhash", output.type)
+        self.assertEqual(1, output.value)
+        self.assertEqual(1, len(output.addresses))
+
+    def test_pubkey_from_hex(self):
+        raw_output = "0100000000000000232102c0993f639534d348e1dca30566491e6c" \
+                     "b11c14afa13ec244c05396a9839aeb17ac"
+        output = Output.from_hex(a2b_hex(raw_output))
+        self.assertTrue(output.is_pubkey())
+        self.assertEqual("pubkey", output.type)
+        self.assertEqual(1, len(output.addresses))
+
+    def test_p2sh_from_hex(self):
+        raw_output = "010000000000000017a91471c5c3727fac8dbace94bd38cf8ac16a" \
+                     "034a794787"
+        output = Output.from_hex(a2b_hex(raw_output))
+
+        self.assertTrue(output.is_p2sh())
+        self.assertEqual("p2sh", output.type)
+        self.assertEqual(1, len(output.addresses))
+
+    def test_return_from_hex(self):
+        raw_output = "01000000000000002a6a2846610000000024958857cc0da391b" \
+                     "7b2bf61bcba59bb9ee438873f902c25da4c079e53d0c55fe991"
+        output = Output.from_hex(a2b_hex(raw_output))
+        self.assertTrue(output.is_return())
+        self.assertEqual("OP_RETURN", output.type)
+        self.assertEqual(0, len(output.addresses))
+
+    def test_multisig_from_hex(self):
+        raw_output = "0100000000000000475121025cd452979d4d5e928d47c3581bb287" \
+                     "41b2cf9c54185e7d563a663707b00d956d2102ff99d00aa9d195b9" \
+                     "3732254def8bfe80a786a7973ef8e63afd8d2a65e97b6c3b52ae"
+        output = Output.from_hex(a2b_hex(raw_output))
+        self.assertTrue(output.is_multisig())
+        self.assertEqual("multisig", output.type)
+        self.assertEqual(2, len(output.addresses))
+
+    def test_unknown_from_hex(self):
+        raw_output = "01000000000000000151"
+        output = Output.from_hex(a2b_hex(raw_output))
+        self.assertEqual("unknown", output.type)
+        self.assertEqual(0, len(output.addresses))

blockchain_parser/tests/test_script.py

@@ -0,0 +1,171 @@
+# 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 unittest
+from binascii import a2b_hex
+from blockchain_parser.script import Script
+
+
+class TestScript(unittest.TestCase):
+    def test_op_return_script(self):
+        case1 = "6a"
+        script = Script.from_hex(a2b_hex(case1))
+        self.assertEqual("OP_RETURN", script.value)
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertTrue(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_unknown_script(self):
+        case = "40"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertEqual("INVALID_SCRIPT", script.value)
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertTrue(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+        case = ""
+        script = Script.from_hex(a2b_hex(case))
+        self.assertEqual("", script.value)
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertTrue(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_multisig_script(self):
+        case = "514104cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4410461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af52ae"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertFalse(script.is_pubkey())
+        self.assertTrue(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_p2sh_script(self):
+        case = "a91428ad3e63dcae36e5010527578e2eef0e9eeaf3e487"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertTrue(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_p2wpkh_script(self):
+        case = "0014c958269b5b6469b6e4b87de1062028ad3bb83cc2"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertTrue(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_p2wsh_script(self):
+        case = "0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertTrue(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_pubkeyhash_script(self):
+        case = "76a914e9629ef6f5b82564a9b2ecae6c288c56fb33710888ac"
+        script = Script.from_hex(a2b_hex(case))
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertTrue(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_pubkey_script(self):
+        script = Script.from_hex(a2b_hex("4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac"))
+        self.assertTrue(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertIs(script.is_p2tr(), False)
+
+    def test_taproot_script(self):
+        # https://blockstream.info/tx/33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036?expand
+        # Second output
+        script = Script.from_hex(a2b_hex("5120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f9"))
+        self.assertFalse(script.is_pubkey())
+        self.assertFalse(script.is_multisig())
+        self.assertFalse(script.is_p2sh())
+        self.assertFalse(script.is_p2wpkh())
+        self.assertFalse(script.is_p2wsh())
+        self.assertFalse(script.is_pubkeyhash())
+        self.assertFalse(script.is_unknown())
+        self.assertFalse(script.is_return())
+        self.assertTrue(script.is_p2tr())
+
+    def test_p2tr_rejects_non_taproot_witness(self):
+        short = Script.from_hex(bytes([0x51, 0x02, 0x00, 0x01]))
+        self.assertIs(short.is_p2tr(), False)
+        self.assertTrue(short.is_unknown())
+
+        extra = Script.from_hex(bytes([0x51, 0x20]) + (b"\x11" * 32) + bytes([0xac]))
+        self.assertIs(extra.is_p2tr(), False)
+
+    def test_invalid_pubkeyhash_length_does_not_raise(self):
+        script = Script.from_hex(bytes([0x20]) + (b"\x00" * 24))
+        self.assertIs(script.is_pubkeyhash(), False)
+        self.assertTrue(script.is_unknown())
+
+    def test_malformed_multisig_does_not_raise(self):
+        pubkey = bytes([0x21, 0x02]) + (b"\xab" * 32)
+        too_few_keys = Script.from_hex(bytes([0x60]) + pubkey + pubkey + pubkey)
+        self.assertIs(too_few_keys.is_multisig(), False)
+        self.assertTrue(too_few_keys.is_unknown())
+
+        mismatched_count = Script.from_hex(bytes([0x51]) + pubkey + bytes([0x52, 0xae]))
+        self.assertIs(mismatched_count.is_multisig(), False)
+        self.assertTrue(mismatched_count.is_unknown())

blockchain_parser/tests/test_transaction.py

@@ -0,0 +1,138 @@
+# 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 os
+import unittest
+from binascii import a2b_hex, b2a_hex
+from blockchain_parser.transaction import Transaction
+
+from .utils import read_test_data
+
+class TestTransaction(unittest.TestCase):
+    def test_rbf(self):
+        data = a2b_hex("01000000019222bbb054bb9f94571dfe769af5866835f2a97e8839"
+                       "59fa757de4064bed8bca01000000035101b1000000000100000000"
+                       "00000000016a01000000")
+        tx = Transaction(data)
+        self.assertTrue(tx.uses_replace_by_fee())
+
+        coinbase = a2b_hex("01000000010000000000000000000000000000000000000000"
+                           "000000000000000000000000ffffffff4203c8e405fabe6d6d"
+                           "98b0e98e3809941f1fd8cafe7c8236e27b8d1a776b1835aa54"
+                           "8bb84fe5b5f3d7010000000000000002650300aaa757eb0000"
+                           "002f736c7573682f0000000001baa98396000000001976a914"
+                           "7c154ed1dc59609e3d26abb2df2ea3d587cd8c4188ac000000"
+                           "00")
+        tx = Transaction(coinbase)
+        self.assertTrue(tx.is_coinbase())
+        self.assertFalse(tx.uses_replace_by_fee())
+
+    def test_bip69(self):
+        non_compliant = read_test_data("bip69_false.txt")
+        tx = Transaction(non_compliant)
+        self.assertFalse(tx.uses_bip69())
+
+        compliant = read_test_data("bip69_true.txt")
+        tx = Transaction(compliant)
+        self.assertTrue(tx.uses_bip69())
+
+    def test_bip69_sorts_scripts_as_bytes(self):
+        def build(scripts):
+            tx_input = b"\x11" * 32 + b"\x00\x00\x00\x00" + b"\x00" + b"\xff" * 4
+            outputs = b""
+            for script in scripts:
+                outputs += (b"\x01" + b"\x00" * 7) + bytes([len(script)]) + script
+            raw = (
+                b"\x01\x00\x00\x00"
+                + b"\x01" + tx_input
+                + bytes([len(scripts)]) + outputs
+                + b"\x00\x00\x00\x00"
+            )
+            return Transaction(raw)
+
+        # 0x6a < 0x76, so OP_RETURN before OP_DUP is the BIP69 byte order.
+        self.assertTrue(build([b"\x6a", b"\x76"]).uses_bip69())
+        self.assertFalse(build([b"\x76", b"\x6a"]).uses_bip69())
+
+    def test_bech32_p2wpkh(self):
+        tx = Transaction(read_test_data("bech32_p2wpkh.txt"))
+        self.assertEqual(["3BBqfnaPbgi5KWECWdFpvryUfw7QatWy37"], [a.address for a in tx.outputs[0].addresses])
+        self.assertEqual(["bc1q4z0874xmfxe3xeqknulgnqhukhfjwh5tvjrr2x"], [a.address for a in tx.outputs[1].addresses])
+
+    def test_bech32_p2wsh(self):
+        tx = Transaction(read_test_data("bech32_p2wsh.txt"))
+        self.assertEqual(["3GMKKFPNUg13VktgihUD8QfXVQRBdoDNDf"], [a.address for a in tx.outputs[0].addresses])
+        self.assertEqual(["bc1qday7wsftyv4r6qkpn8907s8fy3kexkny0xwrd8d4wlk06zffzyuqpp629n"], [a.address for a in tx.outputs[1].addresses])
+
+    def test_segwit(self):
+        tx = Transaction(read_test_data("segwit.txt"))
+        self.assertTrue(tx.is_segwit)
+        id = "22116f1d76ab425ddc6d10d184331e70e080dd6275d7aa90237ceb648dc38224"
+        self.assertTrue(tx.txid == id)
+        h = "1eac09f372a8c13bb7dea6bd66ee71a6bcc469b57b35c1e394ad7eb7c107c507"
+        self.assertTrue(tx.hash == h)
+
+        segwit_input = tx.inputs[0]
+        self.assertTrue(len(segwit_input.witnesses) == 4)
+        self.assertTrue(len(segwit_input.witnesses[0]) == 0)
+
+        wit_1 = "3045022100bc2ba8808127f8a74beed6dfa1b9fe54675c55aab85a61d7" \
+                "a74c15b993e67e5f02204dada4e15f0b4e659dae7bf0d0f648010d1f2b" \
+                "665f587a35eb6f22e44194952301"
+
+        wit_2 = "3045022100f4c7ec7c2064fe2cc4389733ac0a57d8080a62180a004b02" \
+                "a19b89267113a17f022004ee9fdb081359c549ee42ffb58279363563ea" \
+                "f0191cd8b2b0ceebf62146b50b01"
+
+        wit_3 = "5221022b003d276bce58bef509bdcd9cf7e156f0eae18e1175815282e6" \
+                "5e7da788bb5b21035c58f2f60ecf38c9c8b9d1316b662627ec672f5fd9" \
+                "12b1a2cc28d0b9b00575fd2103c96d495bfdd5ba4145e3e046fee45e84" \
+                "a8a48ad05bd8dbb395c011a32cf9f88053ae"
+
+        parsed_1 = b2a_hex(segwit_input.witnesses[1]).decode("utf-8")
+        parsed_2 = b2a_hex(segwit_input.witnesses[2]).decode("utf-8")
+        parsed_3 = b2a_hex(segwit_input.witnesses[3]).decode("utf-8")
+
+        self.assertEqual(parsed_1, wit_1)
+        self.assertEqual(parsed_2, wit_2)
+        self.assertEqual(parsed_3, wit_3)
+
+    def test_vsize(self):
+        segwit_tx = Transaction(read_test_data("size_segwit.txt"))
+        non_segwit_tx = Transaction(read_test_data("size_non_segwit.txt"))
+
+        self.assertEqual(non_segwit_tx.vsize, non_segwit_tx.size)
+        self.assertEqual(non_segwit_tx.vsize, 189)
+
+        self.assertNotEqual(segwit_tx.vsize, segwit_tx.size)
+        self.assertEqual(segwit_tx.vsize, 208)
+        self.assertEqual(segwit_tx.size, 373)
+
+    def test_large(self):
+        data = read_test_data("large_tx.txt")
+
+        tx = Transaction(data)
+        self.assertTrue(
+            tx.hash == "29a3efd3ef04f9153d47a990bd7b048a4b2d213daa"
+                       "a5fb8ed670fb85f13bdbcf")
+        self.assertTrue(tx.size == len(tx.hex))
+
+    def test_incomplete(self):
+        data = read_test_data("invalid_tx.txt")
+
+        self.assertRaises(Exception, Transaction, data)
+
+    def test_unknown_scripts(self):
+        data = read_test_data("scripts_invalid.txt")
+        tx = Transaction(data)
+
+        for output in tx.outputs:
+            self.assertEqual([], output.addresses)

blockchain_parser/tests/test_undo.py

@@ -0,0 +1,70 @@
+import unittest
+
+from blockchain_parser.undo import BlockUndo, decompress_script
+
+
+def _coin(height, program, amount_code=1):
+    # Even height codes are non-coinbase. Height > 0 carries a dummy 0x00.
+    raw = bytes([height * 2])
+    if height > 0:
+        raw += b"\x00"
+    return raw + bytes([amount_code, 0x00]) + program
+
+
+class TestUndo(unittest.TestCase):
+    def test_p2pkh_script_and_amount(self):
+        program = b"\x11" * 20
+        undo = BlockUndo(bytes([1, 1]) + _coin(1, program))
+        spent = undo.spends[0].outputs[0]
+        self.assertEqual(spent.height, 1)
+        self.assertFalse(spent.is_coinbase)
+        self.assertEqual(spent.amt, 1)
+        self.assertEqual(
+            spent.script.hex,
+            b"\x76\xa9\x14" + program + b"\x88\xac",
+        )
+        self.assertTrue(spent.script.is_pubkeyhash())
+
+    def test_height_zero_has_no_dummy_byte(self):
+        program = b"\x22" * 20
+        undo = BlockUndo(bytes([1, 1]) + _coin(0, program))
+        spent = undo.spends[0].outputs[0]
+        self.assertEqual(spent.height, 0)
+        self.assertEqual(spent.amt, 1)
+        self.assertEqual(spent.script.hex[3:23], program)
+
+    def test_second_output_stays_aligned(self):
+        first = _coin(1, b"\x11" * 20)
+        second = _coin(2, b"\x22" * 20)
+        undo = BlockUndo(bytes([1, 2]) + first + second)
+        outputs = undo.spends[0].outputs
+        self.assertEqual(len(outputs), 2)
+        self.assertEqual(outputs[1].height, 2)
+        self.assertEqual(outputs[1].amt, 1)
+        self.assertEqual(outputs[1].script.hex[3:23], b"\x22" * 20)
+
+    def test_p2sh_and_compressed_pubkey(self):
+        program = b"\x44" * 20
+        self.assertEqual(
+            decompress_script(bytes([1]) + program),
+            b"\xa9\x14" + program + b"\x87",
+        )
+        x_only = b"\x11" * 32
+        self.assertEqual(
+            decompress_script(bytes([2]) + x_only),
+            bytes([0x21, 0x02]) + x_only + b"\xac",
+        )
+
+    def test_uncompressed_pubkey_on_secp256k1(self):
+        x_only = bytes.fromhex(
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+        )
+        y_coord = bytes.fromhex(
+            "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
+        )
+        script = decompress_script(bytes([0x04]) + x_only)
+        self.assertEqual(script, bytes([0x41, 0x04]) + x_only + y_coord + b"\xac")
+
+    def test_raw_script(self):
+        raw = b"\x51"
+        self.assertEqual(decompress_script(bytes([6 + len(raw)]) + raw), raw)

blockchain_parser/tests/test_utils.py

@@ -0,0 +1,55 @@
+# 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 unittest
+from binascii import b2a_hex, a2b_hex
+
+from blockchain_parser import utils
+
+
+class TestUtils(unittest.TestCase):
+    def test_btc_ripemd160(self):
+        data = a2b_hex("02218AD6CDC632E7AE7D04472374311CEBBBBF0AB540D2D08C3400BB844C654231")
+        ripe = utils.btc_ripemd160(data)
+        expected = b"5238c71458e464d9ff90299abca4a1d7b9cb76ab"
+        self.assertEqual(b2a_hex(ripe), expected)
+
+    def test_format_hash(self):
+        data = a2b_hex("deadbeef")
+        self.assertEqual(utils.format_hash(data), "efbeadde")
+
+    def test_decode_uint32(self):
+        uint32_dict = {
+            "01000000": 1,
+            "000000ff": 4278190080
+        }
+
+        for uint32, value in uint32_dict.items():
+            self.assertEqual(utils.decode_uint32(a2b_hex(uint32)), value)
+
+    def test_decode_uint64(self):
+        uint64_dict = {
+            "0100000000000000": 1,
+            "00000000000000ff": 18374686479671623680
+        }
+
+        for uint64, value in uint64_dict.items():
+            self.assertEqual(utils.decode_uint64(a2b_hex(uint64)), value)
+
+    def test_decode_compactsize(self):
+        case1 = a2b_hex("fa")
+        self.assertEqual(utils.decode_compactsize(case1), (250, 1))
+        case2 = a2b_hex("fd0100")
+        self.assertEqual(utils.decode_compactsize(case2), (1, 3))
+        case3 = a2b_hex("fe01000000")
+        self.assertEqual(utils.decode_compactsize(case3), (1, 5))
+        case4 = a2b_hex("ff0100000000000000")
+        self.assertEqual(utils.decode_compactsize(case4), (1, 9))

blockchain_parser/tests/utils.py

@@ -0,0 +1,9 @@
+import os
+from binascii import a2b_hex
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+
+def read_test_data(filename):
+    with open(os.path.join(dir_path, "data/", filename)) as f:
+        return a2b_hex(f.read().strip())