def test_address_from_wif(self):
        wif1 = b"5J1geo9kcAUSM6GJJmhYRX1eZEjvos9nFyWwPstVziTVueRJYvW"
        a = address_from_wif(wif1)
        self.assertEqual(a, b'1LPM8SZ4RQDMZymUmVSiSSvrDfj1UZY9ig')

        wif2 = b"Kx621phdUCp6sgEXPSHwhDTrmHeUVrMkm6T95ycJyjyxbDXkr162"
        a = address_from_wif(wif2)
        self.assertEqual(a, b'1HJC7kFvXHepkSzdc8RX6khQKkAyntdfkB')

        self.assertEqual(prvkey_from_wif(wif1)[0], prvkey_from_wif(wif2)[0])
    def test_wif_from_prvkey(self):
        q = 0xC28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D

        # compressed WIF
        wif = wif_from_prvkey(q, True)
        self.assertEqual(
            wif, b'KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617')
        q2 = prvkey_from_wif(wif)
        self.assertEqual(q2[0], q)
        self.assertEqual(q2[1], True)

        # uncompressed WIF
        wif = wif_from_prvkey(q, False)
        self.assertEqual(
            wif, b'5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ')
        q3 = prvkey_from_wif(wif)
        self.assertEqual(q3[0], q)
        self.assertEqual(q3[1], False)

        # private key not in (0, n)
        badq = ec.n
        self.assertRaises(ValueError, wif_from_prvkey, badq, True)
        #wif = wif_from_prvkey(badq, True)

        # Not a private key WIF: missing leading 0x80
        payload = b'\x81' + octets_from_int(badq, ec.psize)
        badwif = base58.encode_check(payload)
        self.assertRaises(ValueError, prvkey_from_wif, badwif)
        #prvkey_from_wif(badwif)

        # Not a compressed WIF: missing trailing 0x01
        payload = b'\x80' + octets_from_int(badq, ec.psize) + b'\x00'
        badwif = base58.encode_check(payload)
        self.assertRaises(ValueError, prvkey_from_wif, badwif)
        # prvkey_from_wif(badwif)

        # Not a WIF: wrong size (35)
        payload = b'\x80' + octets_from_int(badq, ec.psize) + b'\x01\x00'
        badwif = base58.encode_check(payload)
        self.assertRaises(ValueError, prvkey_from_wif, badwif)
        #prvkey_from_wif(badwif)

        # Not a WIF: private key not in (0, n)
        payload = b'\x80' + octets_from_int(badq, ec.psize)
        badwif = base58.encode_check(payload)
        self.assertRaises(ValueError, prvkey_from_wif, badwif)
Exemple #3
0
    def test_address_from_wif(self):
        wif1 = b"5J1geo9kcAUSM6GJJmhYRX1eZEjvos9nFyWwPstVziTVueRJYvW"
        a = address_from_wif(wif1)
        self.assertEqual(a, b'1LPM8SZ4RQDMZymUmVSiSSvrDfj1UZY9ig')

        wif2 = b"Kx621phdUCp6sgEXPSHwhDTrmHeUVrMkm6T95ycJyjyxbDXkr162"
        a = address_from_wif(wif2)
        self.assertEqual(a, b'1HJC7kFvXHepkSzdc8RX6khQKkAyntdfkB')

        self.assertEqual(prvkey_from_wif(wif1)[0], prvkey_from_wif(wif2)[0])

        # testnet
        wif1 = b"91gGn1HgSap6CbU12F6z3pJri26xzp7Ay1VW6NHCoEayNXwRpu2"
        a = address_from_wif(wif1)
        self.assertEqual(a, b'mvgbzkCSgKbYgaeG38auUzR7otscEGi8U7')

        wif2 = b"cMzLdeGd5vEqxB8B6VFQoRopQ3sLAAvEzDAoQgvX54xwofSWj1fx"
        a = address_from_wif(wif2)
        self.assertEqual(a, b'n1KSZGmQgB8iSZqv6UVhGkCGUbEdw8Lm3Q')

        self.assertEqual(prvkey_from_wif(wif1)[0], prvkey_from_wif(wif2)[0])
Exemple #4
0
    def test_wif_from_prvkey(self):
        p_num = 0xC28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
        p_bytes = bytes_from_Scalar(ec, p_num)
        p_hex = p_bytes.hex()

        # private key as number
        wif = wif_from_prvkey(p_num)
        self.assertEqual(
            wif, b'KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617')
        p2 = prvkey_from_wif(wif)
        self.assertEqual(p2[0], p_bytes)
        self.assertEqual(p2[1], True)
        wif = wif_from_prvkey(p_num, False)
        self.assertEqual(
            wif, b'5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ')
        p3 = prvkey_from_wif(wif)
        self.assertEqual(p3[0], p_bytes)
        self.assertEqual(p3[1], False)

        # private key as bytes, i.e. the preferred format
        wif = wif_from_prvkey(p_bytes)
        self.assertEqual(
            wif, b'KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617')
        p4 = prvkey_from_wif(wif)
        self.assertEqual(p4[0], p_bytes)
        self.assertEqual(p4[1], True)
        wif = wif_from_prvkey(p_bytes, False)
        self.assertEqual(
            wif, b'5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ')
        p5 = prvkey_from_wif(wif)
        self.assertEqual(p5[0], p_bytes)
        self.assertEqual(p5[1], False)

        # private key as hex string
        wif = wif_from_prvkey(p_hex)
        self.assertEqual(
            wif, b'KwdMAjGmerYanjeui5SHS7JkmpZvVipYvB2LJGU1ZxJwYvP98617')
        p6 = prvkey_from_wif(wif)
        self.assertEqual(p6[0], p_bytes)
        self.assertEqual(p6[1], True)
        wif = wif_from_prvkey(p_hex, False)
        self.assertEqual(
            wif, b'5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ')
        p7 = prvkey_from_wif(wif)
        self.assertEqual(p7[0], p_bytes)
        self.assertEqual(p7[1], False)

        payload = b'\x80' + p_bytes + b'\x01\x01'
        wif = b58encode_check(payload)
        self.assertRaises(ValueError, prvkey_from_wif, wif)
Exemple #5
0
    def test_signmessage(self):
        msg = "test message"
        # sigs are taken from (Electrum and) Bitcoin Core

        wif = 'L41XHGJA5QX43QRG3FEwPbqD5BYvy6WxUxqAMM9oQdHJ5FcRHcGk'
        prvkey, compressed = prvkey_from_wif(wif)
        self.assertEqual(
            prvkey,
            0xCA978112CA1BBDCAFAC231B39A23DC4DA786EFF8147C4E72B9807785AFEE48BB)
        self.assertTrue(compressed)
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        address = b'14dD6ygPi5WXdwwBTt1FBZK3aD8uDem1FY'
        self.assertEqual(mysig[0], address)
        sig = b"H/iew/NhHV9V9MdUEn/LFOftaTy1ivGPKPKyMlr8OSokNC755fAxpSThNRivwTNsyY9vPUDTRYBPc2cmGd5d4y4="
        self.assertEqual(mysig[1], sig)

        wif = '5KMWWy2d3Mjc8LojNoj8Lcz9B1aWu8bRofUgGwQk959Dw5h2iyw'
        prvkey, compressed = prvkey_from_wif(wif)
        self.assertEqual(
            prvkey,
            0xCA978112CA1BBDCAFAC231B39A23DC4DA786EFF8147C4E72B9807785AFEE48BB)
        self.assertFalse(compressed)
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        address = b'1HUBHMij46Hae75JPdWjeZ5Q7KaL7EFRSD'
        self.assertEqual(mysig[0], address)
        sig = b"G/iew/NhHV9V9MdUEn/LFOftaTy1ivGPKPKyMlr8OSokNC755fAxpSThNRivwTNsyY9vPUDTRYBPc2cmGd5d4y4="
        self.assertEqual(mysig[1], sig)

        wif = 'Ky1XfDK2v6wHPazA6ECaD8UctEoShXdchgABjpU9GWGZDxVRDBMJ'
        prvkey, compressed = prvkey_from_wif(wif)
        self.assertEqual(
            prvkey,
            0x35687eed35e44235053dce4c65dc23b11327ecee9acc51c90651e7072047f886)
        self.assertTrue(compressed)
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        address = b'1DAag8qiPLHh6hMFVu9qJQm9ro1HtwuyK5'
        self.assertEqual(mysig[0], address)
        sig = b"IFqUo4/sxBEFkfK8mZeeN56V13BqOc0D90oPBChF3gTqMXtNSCTN79UxC33kZ8Mi0cHy4zYCnQfCxTyLpMVXKeA="
        self.assertEqual(mysig[1], sig)

        wif = '5JDopdKaxz5bXVYXcAnfno6oeSL8dpipxtU1AhfKe3Z58X48srn'
        prvkey, compressed = prvkey_from_wif(wif)
        self.assertEqual(
            prvkey,
            0x35687eed35e44235053dce4c65dc23b11327ecee9acc51c90651e7072047f886)
        self.assertFalse(compressed)
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        address = b'19f7adDYqhHSJm2v7igFWZAqxXHj1vUa3T'
        self.assertEqual(mysig[0], address)
        sig = b"HFqUo4/sxBEFkfK8mZeeN56V13BqOc0D90oPBChF3gTqMXtNSCTN79UxC33kZ8Mi0cHy4zYCnQfCxTyLpMVXKeA="
        self.assertEqual(mysig[1], sig)

        msg = ''
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'HFh0InGTy8lLCs03yoUIpJU6MUbi0La/4abhVxyKcCsoUiF3RM7lg51rCqyoOZ8Yt43h8LZrmj7nwwO3HIfesiw='
        self.assertEqual(mysig[1], sig)

        msg = ' '
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'HEveV6CMmOk5lFP+oDbw8cir/OkhJn4S767wt+YwhzHnEYcFOb/uC6rrVmTtG3M43mzfObA0Nn1n9CRcv5IGyak='
        self.assertEqual(mysig[1], sig)

        msg = '  '
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'G/QjF1V4fVI8IHX8ko0SIypmb0yxfaZLF0o56Cif9z8CX24n4petTxolH59pYVMvbTKQkGKpznSiPiQVn83eJF0='
        self.assertEqual(mysig[1], sig)

        msg = 'test'
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'HJUtN/2LZjh1Vx8Ekj9opnIKA6ohKhWB95PLT/3EFgLnOu9hTuYX4+tJJ60ZyddFMd6dgAYx15oP+jLw2NzgNUo='
        self.assertEqual(mysig[1], sig)

        # sig is taken from Bitcoin Core
        # (Electrum does strip leading/trailing spaces)
        msg = ' test '
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'HA59z13/HBhvMMJtNwT6K7vJByE40lQUdqEMYhX2tnZSD+IGQIoBGE+1IYGCHCyqHvTvyGeqJTUx5ywb4StuX0s='
        self.assertEqual(mysig[1], sig)

        # sig is taken from Bitcoin Core
        # (Electrum does strip leading/trailing spaces)
        msg = 'test '
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'HPp9l2w0LVYB4FYKBahs+k1/Oa08j+NTuzriDpPWnWQmfU0+UsJNLIPI8Q/gekrWPv6sDeYsFSG9VybUKDPGMuo='
        self.assertEqual(mysig[1], sig)

        # sig is taken from Bitcoin Core
        # (Electrum does strip leading/trailing spaces)
        msg = ' test'
        mysig = sign(msg, prvkey, compressed)
        # auto-consistency check
        self.assertTrue(verify(msg, mysig[0], mysig[1]))
        self.assertEqual(mysig[0], address)
        sig = b'G1nGwD/kcMSmsYU6qihV2l2+Pa+7SPP9zyViZ59VER+QL9cJsIAtu1CuxfYDAVt3kgr4t3a/Es3PV82M6z0eQAo='
        self.assertEqual(mysig[1], sig)