예제 #1
0
    def test_p2sh(self):

        script_type = "p2sh"

        # self-consistency
        pubkey = "02" "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
        pubkey_hash = hash160(pubkey)
        redeem_script = scriptPubKey_from_payload("p2pkh", pubkey_hash)
        payload = hash160(redeem_script)
        script = encode(["OP_HASH160", payload, "OP_EQUAL"])

        # straight to the scriptPubKey
        scriptPubKey = p2sh(redeem_script)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # data -> payload is not invertible (hash functions)

        # address
        network = "mainnet"
        address = base58address.p2sh(decode(redeem_script), network)
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        prefix = NETWORKS[network]["p2sh"]
        address2 = b58address_from_h160(prefix, payload, network)
        self.assertEqual(address, address2)

        scriptPubKey2, network2 = scriptPubKey_from_address(address)
        self.assertEqual(scriptPubKey2, scriptPubKey)
        self.assertEqual(network2, network)

        # documented test case: https://learnmeabitcoin.com/guide/p2sh
        payload = "748284390f9e263a4b766a75d0633c50426eb875"
        script = "a914748284390f9e263a4b766a75d0633c50426eb87587"
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script)
        network = "mainnet"
        address = b"3CK4fEwbMP7heJarmU4eqA3sMbVJyEnU3V"
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        scriptPubKey2, network2 = scriptPubKey_from_address(address)
        self.assertEqual(scriptPubKey2, scriptPubKey)
        self.assertEqual(network2, network)

        # invalid size: 21 bytes instead of 20
        self.assertRaises(ValueError, scriptPubKey_from_payload, "00" * 21,
                          "p2sh")
예제 #2
0
def test_p2wsh() -> None:

    # self-consistency
    pubkey = "02 cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
    pubkey_hash = hash160(pubkey)
    redeem_script = scriptPubKey_from_payload("p2pkh", pubkey_hash)
    payload = sha256(redeem_script)
    scriptPubKey = script.encode([0, payload])
    assert scriptPubKey == p2wsh(script.decode(redeem_script))

    # to the scriptPubKey in two steps (through payload)
    script_type = "p2wsh"
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)

    # back from the scriptPubKey to the payload
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # bech32 address
    network = "mainnet"
    address = bech32address.p2wsh(redeem_script, network)
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    wit_ver = 0
    assert address == b32address_from_witness(wit_ver, payload, network)

    # back from the address to the scriptPubKey
    assert (scriptPubKey, network) == scriptPubKey_from_address(address)

    # p2sh-wrapped base58 address
    address = base58address.p2wsh_p2sh(redeem_script, network)
    assert address == b58address_from_witness(payload, network)
예제 #3
0
    def test_p2pkh(self):

        script_type = 'p2pkh'

        # self-consistency
        pubkey = "04cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
        payload = hash160(pubkey)
        script = encode(['OP_DUP', 'OP_HASH160', payload,
                         'OP_EQUALVERIFY', 'OP_CHECKSIG'])

        # straight to the scriptPubKey
        scriptPubKey = p2pkh(pubkey)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # data -> payload is not invertible (hash functions)

        # address
        network = 'mainnet'
        address = base58address.p2pkh(pubkey, network)
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        prefix = p2pkh_prefix_from_network(network)
        address2 = b58address_from_h160(prefix, payload)
        self.assertEqual(address, address2)

        scriptPubKey2, network2 = scriptPubKey_from_address(address)
        self.assertEqual(scriptPubKey2, scriptPubKey)
        self.assertEqual(network2, network)

        # documented test case: https://learnmeabitcoin.com/guide/p2pkh
        payload = "12ab8dc588ca9d5787dde7eb29569da63c3a238c"
        script = "76a91412ab8dc588ca9d5787dde7eb29569da63c3a238c88ac"
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script)
        network = 'mainnet'
        address = b"12higDjoCCNXSA95xZMWUdPvXNmkAduhWv"
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        scriptPubKey2, network2 = scriptPubKey_from_address(address)
        self.assertEqual(scriptPubKey2, scriptPubKey)
        self.assertEqual(network2, network)

        # Invalid size: 11 bytes instead of 20
        self.assertRaises(
            ValueError, scriptPubKey_from_payload, "00" * 11, 'p2pkh')
예제 #4
0
    def test_p2ms_2(self):

        pubkey1 = (
            "04"
            "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
            "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
        )
        pubkey2 = (
            "04"
            "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
            "19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af"
        )
        pubkey3 = (
            "04"
            "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
            "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8"
        )
        pubkeys = [pubkey1, pubkey2, pubkey3]
        m = 1
        n = len(pubkeys)
        script = [m] + pubkeys + [n, "OP_CHECKMULTISIG"]
        payload_from_scriptPubKey(script)
        scriptPubKey_from_payload("p2ms", pubkeys, m)

        # Invalid list of Octets for p2sh script
        self.assertRaises(ValueError, scriptPubKey_from_payload, "p2sh", pubkeys, 0)
        # scriptPubKey_from_payload('p2sh', pubkeys, 0)

        # Invalid number of keys (0) in m-of-n multisignature
        script = [1, 3, "OP_CHECKMULTISIG"]
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # Keys (2) / n (3) mismatch in m-of-n multisignature
        script = [1, pubkey1, pubkey2, 3, "OP_CHECKMULTISIG"]
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # Impossible 3-of-2 multisignature
        script = [3, pubkey1, pubkey2, 2, "OP_CHECKMULTISIG"]
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # Invalid m (0) in 0-of-2 multisignature
        script = [0, pubkey1, pubkey2, 2, "OP_CHECKMULTISIG"]
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # 133-th byte in 1-of-3 multisignature payload is 0x40,
        # it should have been 0x41
        script = [1, pubkey1, pubkey2, pubkey3, 3, "OP_CHECKMULTISIG"]
        bscript = encode(script)
        script = bscript[:133] + b"\x40" + bscript[134:]
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
예제 #5
0
def test_nulldata() -> None:

    # self-consistency
    string = "time-stamped data"
    payload = string.encode()
    scriptPubKey = script.encode(["OP_RETURN", payload])
    assert scriptPubKey == nulldata(string)

    # to the scriptPubKey in two steps (through payload)
    script_type = "nulldata"
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)

    # back from the scriptPubKey to the payload
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # data -> payload in this case is invertible (no hash functions)
    assert payload.decode() == string

    err_msg = "no address for null data script"
    with pytest.raises(ValueError, match=err_msg):
        address_from_scriptPubKey(scriptPubKey)

    # documented test cases: https://learnmeabitcoin.com/guide/nulldata
    string = "hello world"
    payload = string.encode()
    assert payload.hex() == "68656c6c6f20776f726c64"  # pylint: disable=no-member
    scriptPubKey = b"\x6a\x0b" + payload
    assert scriptPubKey == nulldata(string)
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # documented test cases: https://learnmeabitcoin.com/guide/nulldata
    string = "charley loves heidi"
    payload = string.encode()
    assert (payload.hex()  # pylint: disable=no-member
            == "636861726c6579206c6f766573206865696469")
    scriptPubKey = b"\x6a\x13" + payload
    assert scriptPubKey == nulldata(string)
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # documented test cases: https://learnmeabitcoin.com/guide/nulldata
    string = "家族も友達もみんなが笑顔の毎日がほしい"
    payload = string.encode()
    assert (
        payload.hex()  # pylint: disable=no-member
        ==
        "e5aeb6e6978fe38282e58f8be98194e38282e381bfe38293e381aae3818ce7ac91e9a194e381aee6af8ee697a5e3818ce381bbe38197e38184"
    )
    scriptPubKey = b"\x6a\x39" + payload
    assert scriptPubKey == nulldata(string)
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)
예제 #6
0
def test_p2pk() -> None:

    # self-consistency
    pubkey = "02 cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
    scriptPubKey = script.encode([pubkey, "OP_CHECKSIG"])
    assert scriptPubKey == p2pk(pubkey)

    # to the scriptPubKey in two steps (through payload)
    script_type = "p2pk"
    assert scriptPubKey == scriptPubKey_from_payload(script_type, pubkey)

    # back from the scriptPubKey to the payload
    assert (script_type, bytes.fromhex(pubkey),
            0) == payload_from_scriptPubKey(scriptPubKey)

    err_msg = "no address for p2pk scriptPubKey"
    with pytest.raises(ValueError, match=err_msg):
        address_from_scriptPubKey(scriptPubKey)

    # documented test case: https://learnmeabitcoin.com/guide/p2pk
    pubkey = (
        "04"
        "ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414"
        "e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84c")
    scriptPubKey = "41" + pubkey + "ac"
    assert scriptPubKey == p2pk(pubkey).hex()

    # invalid size: 34 bytes instead of (33, 65)
    pubkey = (  # fmt: off
        "03"
        "ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414"
        "14")  # fmt: on
    err_msg = "not a private or public key: "
    with pytest.raises(ValueError, match=err_msg):
        p2pk(pubkey)
예제 #7
0
    def test_CLT(self):

        network = 'mainnet'

        vault_pubkeys = [b'\x00' * 33, b'\x11' * 33, b'\x22' * 33]
        recovery_pubkeys = [b'\x77' * 33, b'\x88' * 33, b'\x99' * 33]
        redeem_script = encode([
            'OP_IF',
            2, *vault_pubkeys, 3, 'OP_CHECKMULTISIG',
            'OP_ELSE',
            500, 'OP_CHECKLOCKTIMEVERIFY', 'OP_DROP',
            2, *recovery_pubkeys, 3, 'OP_CHECKMULTISIG',
            'OP_ENDIF'
        ])
        payload = sha256(redeem_script)
        script = "00207b5310339c6001f75614daa5083839fa54d46165f6c56025cc54d397a85a5708"

        scriptPubKey = p2wsh(redeem_script)
        self.assertEqual(scriptPubKey.hex(), script)
        scriptPubKey = scriptPubKey_from_payload('p2wsh', payload)
        self.assertEqual(scriptPubKey.hex(), script)

        address = b"bc1q0df3qvuuvqqlw4s5m2jsswpelf2dgct97mzkqfwv2nfe02z62uyq7n4zjj"
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        address2 = bech32address.p2wsh(redeem_script, network)
        self.assertEqual(address, address2)
        address2 = b32address_from_witness(0, payload, network)
        self.assertEqual(address, address2)
예제 #8
0
    def test_p2ms_3(self):

        # mixed compressed / uncompressed public keys
        pubkey1 = (
            "04"
            "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
            "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
        )
        pubkey2 = (
            "03" "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
        )
        pubkey3 = (
            "02" "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
        )
        pubkeys = [
            bytes.fromhex(pubkey1),
            bytes.fromhex(pubkey2),
            bytes.fromhex(pubkey3),
        ]
        m = 1
        n = len(pubkeys)
        script = scriptPubKey_from_payload("p2ms", pubkeys, m)
        pubkeys.sort()
        exp_script = encode([m] + pubkeys + [n, "OP_CHECKMULTISIG"])
        self.assertEqual(script.hex(), exp_script.hex())
        script_type, payload, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, "p2ms")
        self.assertEqual(m, m2)
        self.assertEqual(pubkeys, payload)
예제 #9
0
def test_CLT() -> None:

    network = "mainnet"

    fed_pubkeys = [b"\x00" * 33, b"\x11" * 33, b"\x22" * 33]
    rec_pubkeys = [b"\x77" * 33, b"\x88" * 33, b"\x99" * 33]
    # fmt: off
    redeem_script = script.encode([
        "OP_IF",
        2,
        *fed_pubkeys,
        3,
        "OP_CHECKMULTISIG",  # noqa E131
        "OP_ELSE",
        500,
        "OP_CHECKLOCKTIMEVERIFY",
        "OP_DROP",  # noqa E131
        2,
        *rec_pubkeys,
        3,
        "OP_CHECKMULTISIG",  # noqa E131
        "OP_ENDIF",
    ])
    # fmt: on
    payload = sha256(redeem_script)
    scriptPubKey = (
        "00207b5310339c6001f75614daa5083839fa54d46165f6c56025cc54d397a85a5708")
    assert scriptPubKey == p2wsh(redeem_script).hex()
    assert scriptPubKey == scriptPubKey_from_payload("p2wsh", payload).hex()

    address = b"bc1q0df3qvuuvqqlw4s5m2jsswpelf2dgct97mzkqfwv2nfe02z62uyq7n4zjj"
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    assert address == b32address_from_witness(0, payload, network)
예제 #10
0
def test_p2ms_p2sh() -> None:
    "BIP67 test vectors https://en.bitcoin.it/wiki/BIP_0067"

    data_folder = path.join(path.dirname(__file__), "test_data")
    filename = path.join(data_folder, "bip67_test_vectors.json")
    with open(filename, "r") as f:
        # json.dump(test_vectors, f, indent=4)
        test_vectors = json.load(f)

    m = 2
    for i in test_vectors:
        keys, address = test_vectors[i]
        errmsg = f"Test vector #{int(i)}"
        scriptPubKey = p2ms(keys, m)
        addr = base58address.p2sh(scriptPubKey)
        assert addr.decode() == address, errmsg

        scriptPubKey = scriptPubKey_from_payload("p2ms", keys, m)
        addr = base58address.p2sh(scriptPubKey)
        assert addr.decode() == address, errmsg

        script_type, payload, m2 = payload_from_scriptPubKey(scriptPubKey)
        assert script_type == "p2ms", errmsg
        for key, k in zip(sorted(keys), payload):
            assert key == k.hex(), errmsg
        assert m2 == m, errmsg
예제 #11
0
    def test_p2wsh(self):

        script_type = "p2wsh"

        # self-consistency
        pubkey = "02" "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
        pubkey_hash = hash160(pubkey)
        redeem_script = scriptPubKey_from_payload("p2pkh", pubkey_hash)
        payload = sha256(redeem_script)
        script = encode([0, payload])

        # straight to the scriptPubKey
        scriptPubKey = p2wsh(decode(redeem_script))
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # data -> payload is not invertible (hash functions)

        # bech32 address
        network = "mainnet"
        address = bech32address.p2wsh(redeem_script, network)
        address2 = address_from_scriptPubKey(scriptPubKey, network)
        self.assertEqual(address, address2)
        address2 = b32address_from_witness(0, payload, network)
        self.assertEqual(address, address2)

        scriptPubKey2, network2 = scriptPubKey_from_address(address)
        self.assertEqual(scriptPubKey2, scriptPubKey)
        self.assertEqual(network2, network)

        # p2sh-wrapped base58 address
        address = base58address.p2wsh_p2sh(redeem_script, network)
        address2 = b58address_from_witness(payload, network)
        self.assertEqual(address, address2)
예제 #12
0
def test_p2pkh() -> None:

    # self-consistency
    pubkey = (
        "04 "
        "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
        "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4")
    payload = hash160(pubkey)
    scriptPubKey = script.encode(
        ["OP_DUP", "OP_HASH160", payload, "OP_EQUALVERIFY", "OP_CHECKSIG"])
    assert scriptPubKey == p2pkh(pubkey)

    # to the scriptPubKey in two steps (through payload)
    script_type = "p2pkh"
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)

    # back from the scriptPubKey to the payload
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # base58 address
    network = "mainnet"
    address = base58address.p2pkh(pubkey, network)
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    prefix = NETWORKS[network]["p2pkh"]
    assert address == b58address_from_h160(prefix, payload, network)

    # back from the address to the scriptPubKey
    assert (scriptPubKey, network) == scriptPubKey_from_address(address)

    # documented test case: https://learnmeabitcoin.com/guide/p2pkh
    payload = "12ab8dc588ca9d5787dde7eb29569da63c3a238c"
    scriptPubKey = "76a914" + payload + "88ac"
    assert scriptPubKey == scriptPubKey_from_payload(script_type,
                                                     payload).hex()
    address = b"12higDjoCCNXSA95xZMWUdPvXNmkAduhWv"
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    assert (bytes.fromhex(scriptPubKey),
            network) == scriptPubKey_from_address(address)

    # invalid size: 11 bytes instead of 20
    err_msg = "invalid size: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload(script_type, "00" * 11)
예제 #13
0
    def test_p2ms_p2sh(self):
        test_vectors = [
            [0,
                ['022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b150a0f85014da',
                 '03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209fba0d90de6e9',
                 '021f2f6e1e50cb6a953935c3601284925decd3fd21bc445712576873fb8c6ebc18',
                 ],
             b'3Q4sF6tv9wsdqu2NtARzNCpQgwifm2rAba'
             ],
            [1,
                ['02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8',
                 '02fe6f0a5a297eb38c391581c4413e084773ea23954d93f7753db7dc0adc188b2f',
                 ],
                b'39bgKC7RFbpoCRbtD5KEdkYKtNyhpsNa3Z'
             ],
            [2,
                ['02632b12f4ac5b1d1b72b2a3b508c19172de44f6f46bcee50ba33f3f9291e47ed0',
                 '027735a29bae7780a9755fae7a1c4374c656ac6a69ea9f3697fda61bb99a4f3e77',
                 '02e2cc6bd5f45edd43bebe7cb9b675f0ce9ed3efe613b177588290ad188d11b404',
                 ],
                b'3CKHTjBKxCARLzwABMu9yD85kvtm7WnMfH'
             ],
            [3,
                ['030000000000000000000000000000000000004141414141414141414141414141',
                 '020000000000000000000000000000000000004141414141414141414141414141',
                 '020000000000000000000000000000000000004141414141414141414141414140',
                 '030000000000000000000000000000000000004141414141414141414141414140',
                 ],
                b'32V85igBri9zcfBRVupVvwK18NFtS37FuD'
             ],
            [4,
                ['022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b150a0f85014da',
                 '03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209fba0d90de6e9',
                 '021f2f6e1e50cb6a953935c3601284925decd3fd21bc445712576873fb8c6ebc18',
                 ],
                b'3Q4sF6tv9wsdqu2NtARzNCpQgwifm2rAba'
             ],
        ]

        m = 2
        for i, keys, address in test_vectors:
            errmsg = f"Test vector #{int(i)}"
            script = p2ms(keys, m)
            addr = base58address.p2sh(script)
            self.assertEqual(addr, address, errmsg)

            script = scriptPubKey_from_payload('p2ms', keys, m)
            addr = base58address.p2sh(script)
            self.assertEqual(addr, address, errmsg)

            script_type, payload, m2 = payload_from_scriptPubKey(script)
            self.assertEqual(script_type, 'p2ms', errmsg)
            for key, k in zip(sorted(keys), payload):
                self.assertEqual(key, k.hex(), errmsg)
            self.assertEqual(m2, m, errmsg)
예제 #14
0
def test_p2ms_2() -> None:

    pubkey1 = "04 cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
    pubkey2 = "04 61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765 19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af"
    pubkey3 = "04 79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8"
    pubkeys = [pubkey1, pubkey2, pubkey3]
    m = 1
    n = len(pubkeys)
    scriptPubKey = [m] + pubkeys + [n, "OP_CHECKMULTISIG"]
    payload_from_scriptPubKey(scriptPubKey)
    scriptPubKey_from_payload("p2ms", pubkeys, m)

    err_msg = "invalid list of Octets for p2sh scriptPubKey"
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload("p2sh", pubkeys, 0)

    err_msg = "invalid number of pubkeys in "
    scriptPubKey = [1, 3, "OP_CHECKMULTISIG"]
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    err_msg = "wrong number of pubkeys in "
    scriptPubKey = [1, pubkey1, pubkey2, 3, "OP_CHECKMULTISIG"]
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    err_msg = "invalid number of pubkeys in "
    scriptPubKey = [3, pubkey1, pubkey2, 2, "OP_CHECKMULTISIG"]
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    err_msg = "invalid m in m-of-n multisignature: "
    scriptPubKey = [0, pubkey1, pubkey2, 2, "OP_CHECKMULTISIG"]
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    scriptPubKey = script.encode(
        [1, pubkey1, pubkey2, pubkey3, 3, "OP_CHECKMULTISIG"])
    scriptPubKey = scriptPubKey[:133] + b"\x40" + scriptPubKey[134:]
    err_msg = "wrong number of pubkeys in "
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)
예제 #15
0
def test_p2sh() -> None:

    # self-consistency
    pubkey = "02 cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
    pubkey_hash = hash160(pubkey)
    redeem_script = scriptPubKey_from_payload("p2pkh", pubkey_hash)
    payload = hash160(redeem_script)
    scriptPubKey = script.encode(["OP_HASH160", payload, "OP_EQUAL"])
    assert scriptPubKey == p2sh(redeem_script)

    # to the scriptPubKey in two steps (through payload)
    script_type = "p2sh"
    assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)

    # back from the scriptPubKey to the payload
    assert (script_type, payload, 0) == payload_from_scriptPubKey(scriptPubKey)

    # base58 address
    network = "mainnet"
    address = base58address.p2sh(script.decode(redeem_script), network)
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    prefix = NETWORKS[network]["p2sh"]
    assert address == b58address_from_h160(prefix, payload, network)

    # back from the address to the scriptPubKey
    assert (scriptPubKey, network) == scriptPubKey_from_address(address)

    # documented test case: https://learnmeabitcoin.com/guide/p2sh
    payload = "748284390f9e263a4b766a75d0633c50426eb875"
    scriptPubKey = "a914" + payload + "87"
    assert scriptPubKey == scriptPubKey_from_payload(script_type,
                                                     payload).hex()
    address = b"3CK4fEwbMP7heJarmU4eqA3sMbVJyEnU3V"
    assert address == address_from_scriptPubKey(scriptPubKey, network)
    assert (bytes.fromhex(scriptPubKey),
            network) == scriptPubKey_from_address(address)

    # invalid size: 21 bytes instead of 20
    err_msg = "invalid size: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload(script_type, "00" * 21)
예제 #16
0
    def test_p2pk(self):

        script_type = "p2pk"

        # self-consistency
        pubkey = "02" "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
        script = encode([pubkey, "OP_CHECKSIG"])

        # straight to the scriptPubKey
        scriptPubKey = p2pk(pubkey)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, pubkey)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(bytes.fromhex(pubkey).hex(), payload2.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(bytes.fromhex(pubkey).hex(), payload2.hex())

        # data -> payload in this case is invertible (no hash functions)

        # No address for p2pk script
        self.assertRaises(ValueError, address_from_scriptPubKey, scriptPubKey)
        # address_from_scriptPubKey(scriptPubKey)

        # documented test case: https://learnmeabitcoin.com/guide/p2pk
        pubkey = (
            "04"
            "ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414"
            "e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84c"
        )

        script = (
            "4104"
            "ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414"
            "e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84c"
            "ac"
        )
        scriptPubKey = p2pk(pubkey)
        self.assertEqual(scriptPubKey.hex(), script)

        # Invalid size: 34 bytes instead of (33, 65)
        pubkey = (
            "03" "ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414" "14"
        )
        self.assertRaises(ValueError, p2pk, pubkey)
예제 #17
0
def test_exceptions() -> None:

    # invalid size: 11 bytes instead of 20
    err_msg = "invalid size: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload("p2wpkh", "00" * 11)

    # invalid size: 33 bytes instead of 32
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload("p2wsh", "00" * 33)

    err_msg = "unknown scriptPubKey type: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload("p2unkn", "00" * 32)

    err_msg = "unknown scriptPubKey: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey = [16, 20 * b"\x00"]
        address_from_scriptPubKey(scriptPubKey)

    # Unhandled witness version (16)
    err_msg = "unmanaged witness version: "
    address = b32address_from_witness(16, 20 * b"\x00")
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_address(address)
예제 #18
0
def test_nulldata3() -> None:

    err_msg = "invalid nulldata script lenght: "
    with pytest.raises(ValueError, match=err_msg):
        payload = "00" * 81
        scriptPubKey_from_payload("nulldata", payload)

    # wrong data lenght: 32 in 35-bytes nulldata script;
    # it should have been 33
    scriptPubKey = script.encode(["OP_RETURN", b"\x00" * 33])
    scriptPubKey = scriptPubKey[:1] + b"\x20" + scriptPubKey[2:]
    err_msg = "wrong data lenght: "
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    # wrong data lenght: 32 in 83-bytes nulldata script;
    # it should have been 80
    scriptPubKey = script.encode(["OP_RETURN", b"\x00" * 80])
    scriptPubKey = scriptPubKey[:2] + b"\x20" + scriptPubKey[3:]
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    # missing OP_PUSHDATA1 (0x4c) in 83-bytes nulldata script,
    # got 0x20 instead
    scriptPubKey = script.encode(["OP_RETURN", b"\x00" * 80])
    scriptPubKey = scriptPubKey[:1] + b"\x20" + scriptPubKey[2:]
    err_msg = "missing OP_PUSHDATA1 "
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    assert len(script.encode(["OP_RETURN", b"\x00" * 75])) == 77
    assert len(script.encode(["OP_RETURN", b"\x00" * 76])) == 79
    scriptPubKey = script.encode(["OP_RETURN", b"\x00" * 76])[:-1]
    err_msg = "invalid 78 bytes nulldata script length"
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)
예제 #19
0
def test_nulldata2() -> None:

    script_type = "nulldata"

    # max length case
    byte = b"\x00"
    for length in (0, 1, 16, 17, 74, 75, 76, 77, 78, 79, 80):
        payload = byte * length
        scriptPubKey = script.encode(["OP_RETURN", payload])
        assert scriptPubKey == scriptPubKey_from_payload(script_type, payload)

        # back from the scriptPubKey to the payload
        assert (script_type, payload,
                0) == payload_from_scriptPubKey(scriptPubKey)
        assert (script_type, payload,
                0) == payload_from_scriptPubKey(script.decode(scriptPubKey))
예제 #20
0
def test_p2ms_3() -> None:

    # mixed compressed / uncompressed public keys
    pubkey1 = "04 cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
    pubkey2 = "03 61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
    pubkey3 = "02 79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
    pubkeys = [
        bytes.fromhex(pubkey1),
        bytes.fromhex(pubkey2),
        bytes.fromhex(pubkey3),
    ]
    m = 1
    n = len(pubkeys)
    scriptPubKey = scriptPubKey_from_payload("p2ms", pubkeys, m)
    pubkeys.sort()
    exp_script = script.encode([m] + pubkeys + [n, "OP_CHECKMULTISIG"])
    assert scriptPubKey.hex() == exp_script.hex()
    script_type, payload, m2 = payload_from_scriptPubKey(scriptPubKey)
    assert script_type == "p2ms"
    assert m == m2
    assert pubkeys == payload
예제 #21
0
def test_CLT():

    network = "mainnet"

    vault_pubkeys = [b"\x00" * 33, b"\x11" * 33, b"\x22" * 33]
    recovery_pubkeys = [b"\x77" * 33, b"\x88" * 33, b"\x99" * 33]
    redeem_script = encode(
        [
            "OP_IF",
            2,
            *vault_pubkeys,
            3,
            "OP_CHECKMULTISIG",
            "OP_ELSE",
            500,
            "OP_CHECKLOCKTIMEVERIFY",
            "OP_DROP",
            2,
            *recovery_pubkeys,
            3,
            "OP_CHECKMULTISIG",
            "OP_ENDIF",
        ]
    )
    payload = sha256(redeem_script)
    script = "00207b5310339c6001f75614daa5083839fa54d46165f6c56025cc54d397a85a5708"

    scriptPubKey = p2wsh(redeem_script)
    assert scriptPubKey.hex() == script
    scriptPubKey = scriptPubKey_from_payload("p2wsh", payload)
    assert scriptPubKey.hex() == script

    address = (
        "bc1q0df3qvuuvqqlw4s5m2jsswpelf2dgct97mzkqfwv2nfe02z62uyq7n4zjj"
    ).encode()
    address2 = address_from_scriptPubKey(scriptPubKey, network)
    assert address == address2
    assert address == address2
    address2 = b32address_from_witness(0, payload, network)
    assert address == address2
예제 #22
0
    def test_nulldata2(self):

        script_type = "nulldata"

        # max length case
        byte = b"\x00"
        for length in (0, 1, 16, 17, 74, 75, 80):
            payload = byte * length
            script = encode(["OP_RETURN", payload])

            scriptPubKey = scriptPubKey_from_payload(script_type, payload)
            self.assertEqual(scriptPubKey.hex(), script.hex())

            # back from the scriptPubKey to the payload
            script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
            self.assertEqual(script_type, script_type2)
            self.assertEqual(0, m2)
            self.assertEqual(payload.hex(), payload2.hex())
            script_type2, payload2, m2 = payload_from_scriptPubKey(decode(script))
            self.assertEqual(script_type, script_type2)
            self.assertEqual(0, m2)
            self.assertEqual(payload.hex(), payload2.hex())
예제 #23
0
    def test_p2ms(self):

        script_type = "p2ms"

        # self-consistency
        pubkey1 = (
            "04"
            "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
            "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
        )
        pubkey2 = (
            "04"
            "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
            "19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af"
        )
        pubkeys = [bytes.fromhex(pubkey1), bytes.fromhex(pubkey2)]
        m = 1

        # straight to the scriptPubKey
        scriptPubKey = p2ms(pubkeys, m)
        n = len(pubkeys)
        script = encode([m] + sorted(pubkeys) + [n, "OP_CHECKMULTISIG"])
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, pubkeys, m)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(m, m2)
        self.assertEqual(sorted(pubkeys), payload2)
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(m, m2)
        self.assertEqual(sorted(pubkeys), payload2)

        # data -> payload in this case is invertible (no hash functions)

        # No address for p2ms script
        self.assertRaises(ValueError, address_from_scriptPubKey, scriptPubKey)
        # address_from_scriptPubKey(scriptPubKey)

        # documented test case: https://learnmeabitcoin.com/guide/p2ms
        pubkey1 = (
            "04"
            "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
            "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
        )
        pubkey2 = (
            "04"
            "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
            "19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af"
        )
        pubkeys = [bytes.fromhex(pubkey1), bytes.fromhex(pubkey2)]
        m = 1
        n = 2
        script = (
            "51"  # OP_1
            "41"  # canonical 65-bytes push
            "04"
            "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
            "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4"
            "41"  # canonical 65-bytes push
            "04"
            "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
            "19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af"
            "52"  # OP_2
            "ae"  # OP_CHECKMULTISIG
        )
        scriptPubKey = p2ms(pubkeys, 1, lexicographic_sort=False)
        self.assertEqual(scriptPubKey.hex(), script)

        # Impossible m>n 3-of-2 multisignature
        self.assertRaises(ValueError, p2ms, pubkeys, 3)
        # p2ms(pubkeys, 3)

        # Invalid m (0) for p2ms script
        self.assertRaises(ValueError, p2ms, pubkeys, 0)
        # p2ms(pubkeys, 0)

        # Invalid size: 66 bytes instead of 65
        self.assertRaises(ValueError, p2ms, [pubkey1 + "00", pubkey2], 1)
        # p2ms([pubkey1 + "00", pubkey2], 1)

        # Invalid n (17) in 3-of-17 multisignature
        self.assertRaises(ValueError, p2ms, [pubkey1] * 17, 3)
        # p2ms([pubkey1]*17, 3)

        # Invalid key length (66) in p2ms
        badpubkeys = sorted(pubkeys)
        badpubkeys[0] = badpubkeys[0] + b"\x00"
        self.assertRaises(
            ValueError, scriptPubKey_from_payload, script_type, badpubkeys, m
        )
        # scriptPubKey_from_payload(script_type, badpubkeys, m)

        # Invalid key length (66) in p2ms
        script = encode([m] + sorted(badpubkeys) + [n, "OP_CHECKMULTISIG"])
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # Invalid key in p2ms
        script = encode([m] + [0, pubkeys[1]] + [n, "OP_CHECKMULTISIG"])
        self.assertRaises(ValueError, payload_from_scriptPubKey, script)
        # payload_from_scriptPubKey(script)

        # Invalid m (0) for p2ms script
        self.assertRaises(
            ValueError, scriptPubKey_from_payload, script_type, pubkeys, 17
        )
예제 #24
0
def test_p2ms() -> None:

    script_type = "p2ms"

    # self-consistency
    pubkey1 = (
        "04"
        "cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaf"
        "f7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4")
    pubkey2 = (
        "04"
        "61cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d765"
        "19aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af")
    pubkeys = [bytes.fromhex(pubkey1), bytes.fromhex(pubkey2)]
    m = 1

    # straight to the scriptPubKey
    payload = sorted(pubkeys)
    n = len(pubkeys)
    scriptPubKey = script.encode([m] + payload + [n, "OP_CHECKMULTISIG"])
    assert scriptPubKey == p2ms(pubkeys, m)

    # to the scriptPubKey in two steps (through payload)
    assert scriptPubKey == scriptPubKey_from_payload(script_type, pubkeys, m)

    # back from the scriptPubKey to the payload
    assert (script_type, payload, m) == payload_from_scriptPubKey(scriptPubKey)

    err_msg = "no address for p2ms scriptPubKey"
    with pytest.raises(ValueError, match=err_msg):
        address_from_scriptPubKey(scriptPubKey)

    # documented test case: https://learnmeabitcoin.com/guide/p2ms
    pubkeys = [bytes.fromhex(pubkey1), bytes.fromhex(pubkey2)]
    m = 1
    n = 2
    scriptPubKey = (  # fmt: off
        "51"  # OP_1
        "41"  # canonical 65-bytes push
        + pubkey1 + "41"  # noqa E148  # canonical 65-bytes push
        + pubkey2 + "52"  # noqa E148  # OP_2
        "ae"  # OP_CHECKMULTISIG
    )  # fmt: on
    assert scriptPubKey == p2ms(pubkeys, 1, lexicographic_sort=False).hex()

    err_msg = "number-of-pubkeys < m in "
    with pytest.raises(ValueError, match=err_msg):
        p2ms(pubkeys, 3)

    err_msg = "invalid m for p2ms scriptPubKey: "
    with pytest.raises(ValueError, match=err_msg):
        p2ms(pubkeys, 0)

    err_msg = "not a private or public key: "
    with pytest.raises(ValueError, match=err_msg):
        p2ms([pubkey1 + "00", pubkey2], 1)

    err_msg = "too many pubkeys in m-of-n multisignature: "
    with pytest.raises(ValueError, match=err_msg):
        p2ms([pubkey1] * 17, 3)

    err_msg = "invalid size: "
    badpubkeys = sorted(pubkeys)
    badpubkeys[0] = badpubkeys[0] + b"\x00"
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload(script_type, badpubkeys, m)

    scriptPubKey = script.encode([m] + sorted(badpubkeys) +
                                 [n, "OP_CHECKMULTISIG"])
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    err_msg = "invalid key in p2ms"
    scriptPubKey = script.encode([m] + [0, pubkeys[1]] +
                                 [n, "OP_CHECKMULTISIG"])
    with pytest.raises(ValueError, match=err_msg):
        payload_from_scriptPubKey(scriptPubKey)

    err_msg = "invalid m in m-of-n multisignature: "
    with pytest.raises(ValueError, match=err_msg):
        scriptPubKey_from_payload(script_type, pubkeys, 17)
예제 #25
0
    def test_p2ms_p2sh(self):
        "BIP67 test vectors https://en.bitcoin.it/wiki/BIP_0067"

        test_vectors = {
            0: [
                [
                    (
                        "022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b1"
                        "50a0f85014da"
                    ),
                    (
                        "03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209"
                        "fba0d90de6e9"
                    ),
                    (
                        "021f2f6e1e50cb6a953935c3601284925decd3fd21bc4457125768"
                        "73fb8c6ebc18"
                    ),
                ],
                b"3Q4sF6tv9wsdqu2NtARzNCpQgwifm2rAba",
            ],
            1: [
                [
                    (
                        "02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3"
                        "b2763ed605f8"
                    ),
                    (
                        "02fe6f0a5a297eb38c391581c4413e084773ea23954d93f7753db7"
                        "dc0adc188b2f"
                    ),
                ],
                b"39bgKC7RFbpoCRbtD5KEdkYKtNyhpsNa3Z",
            ],
            2: [
                [
                    (
                        "02632b12f4ac5b1d1b72b2a3b508c19172de44f6f46bcee50ba33f"
                        "3f9291e47ed0"
                    ),
                    (
                        "027735a29bae7780a9755fae7a1c4374c656ac6a69ea9f3697fda6"
                        "1bb99a4f3e77"
                    ),
                    (
                        "02e2cc6bd5f45edd43bebe7cb9b675f0ce9ed3efe613b177588290"
                        "ad188d11b404"
                    ),
                ],
                b"3CKHTjBKxCARLzwABMu9yD85kvtm7WnMfH",
            ],
            3: [
                [
                    (
                        "030000000000000000000000000000000000004141414141414141"
                        "414141414141"
                    ),
                    (
                        "020000000000000000000000000000000000004141414141414141"
                        "414141414141"
                    ),
                    (
                        "020000000000000000000000000000000000004141414141414141"
                        "414141414140"
                    ),
                    (
                        "030000000000000000000000000000000000004141414141414141"
                        "414141414140"
                    ),
                ],
                b"32V85igBri9zcfBRVupVvwK18NFtS37FuD",
            ],
            4: [
                [
                    (
                        "022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b1"
                        "50a0f85014da"
                    ),
                    (
                        "03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209"
                        "fba0d90de6e9"
                    ),
                    (
                        "021f2f6e1e50cb6a953935c3601284925decd3fd21bc4457125768"
                        "73fb8c6ebc18"
                    ),
                ],
                b"3Q4sF6tv9wsdqu2NtARzNCpQgwifm2rAba",
            ],
        }

        m = 2
        for i in test_vectors:
            keys, address = test_vectors[i]
            errmsg = f"Test vector #{int(i)}"
            script = p2ms(keys, m)
            addr = base58address.p2sh(script)
            self.assertEqual(addr, address, errmsg)

            script = scriptPubKey_from_payload("p2ms", keys, m)
            addr = base58address.p2sh(script)
            self.assertEqual(addr, address, errmsg)

            script_type, payload, m2 = payload_from_scriptPubKey(script)
            self.assertEqual(script_type, "p2ms", errmsg)
            for key, k in zip(sorted(keys), payload):
                self.assertEqual(key, k.hex(), errmsg)
            self.assertEqual(m2, m, errmsg)
예제 #26
0
    def test_nulldata(self):

        script_type = "nulldata"

        # self-consistency
        string = "time-stamped data"
        payload = string.encode()
        script = encode(["OP_RETURN", payload])

        # straight to the scriptPubKey
        scriptPubKey = nulldata(string)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # to the scriptPubKey in two steps (through payload)
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())

        # back from the scriptPubKey to the payload
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(script)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # data -> payload in this case is invertible (no hash functions)
        self.assertEqual(payload.decode(), string)

        # No address for null data script
        self.assertRaises(ValueError, address_from_scriptPubKey, scriptPubKey)
        # address_from_scriptPubKey(scriptPubKey)

        # documented test cases: https://learnmeabitcoin.com/guide/nulldata
        string = "hello world"
        payload = string.encode()
        self.assertEqual(payload.hex(), "68656c6c6f20776f726c64")
        script = bytes.fromhex("6a0b68656c6c6f20776f726c64")
        scriptPubKey = nulldata(string)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # documented test cases: https://learnmeabitcoin.com/guide/nulldata
        string = "charley loves heidi"
        payload = string.encode()
        self.assertEqual(payload.hex(), "636861726c6579206c6f766573206865696469")
        script = bytes.fromhex("6a13636861726c6579206c6f766573206865696469")
        scriptPubKey = nulldata(string)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload.hex(), payload2.hex())

        # documented test cases: https://learnmeabitcoin.com/guide/nulldata
        string = "家族も友達もみんなが笑顔の毎日がほしい"
        payload = (
            "e5aeb6e6978fe38282e58f8be98194e38282e381bfe38293e381aae38"
            "18ce7ac91e9a194e381aee6af8ee697a5e3818ce381bbe38197e38184"
        )
        self.assertEqual(string.encode().hex(), payload)
        script = bytes.fromhex(
            "6a39e5aeb6e6978fe38282e58f8be98194e38282e381bfe38293e381aae3818c"
            "e7ac91e9a194e381aee6af8ee697a5e3818ce381bbe38197e38184"
        )
        scriptPubKey = nulldata(string)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        scriptPubKey = scriptPubKey_from_payload(script_type, payload)
        self.assertEqual(scriptPubKey.hex(), script.hex())
        script_type2, payload2, m2 = payload_from_scriptPubKey(scriptPubKey)
        self.assertEqual(script_type, script_type2)
        self.assertEqual(0, m2)
        self.assertEqual(payload, payload2.hex())