├── README.md
├── keyUtils.py
├── makeAddr.py
├── makeTransaction.py
├── mine.py
├── minimalPeerConnection.py
├── minimalSendTxn.py
├── msgUtils.py
├── sendBitcoinTransaction.py
├── txnUtils.py
└── utils.py


/README.md:
--------------------------------------------------------------------------------
1 | Example Python files for 
2 | Bitcoins the hard way: Using the raw Bitcoin protocol
3 | http://www.righto.com/2014/02/bitcoins-hard-way-using-raw-bitcoin.html
4 | 
5 | These files are for illustration of how the Bitcoin protocol works
6 | and should not be used for real purposes.
7 | 


--------------------------------------------------------------------------------
/keyUtils.py:
--------------------------------------------------------------------------------
  1 | # https://pypi.python.org/pypi/ecdsa/0.10
  2 | import ecdsa
  3 | import ecdsa.der
  4 | import ecdsa.util
  5 | import hashlib
  6 | import unittest
  7 | import random
  8 | import re
  9 | import struct
 10 | 
 11 | import utils
 12 | 
 13 | # https://en.bitcoin.it/wiki/Wallet_import_format
 14 | def privateKeyToWif(key_hex):    
 15 |     return utils.base58CheckEncode(0x80, key_hex.decode('hex'))
 16 | 
 17 | def wifToPrivateKey(s):
 18 |     b = utils.base58CheckDecode(s)
 19 |     return b.encode('hex')
 20 | 
 21 | # Input is a hex-encoded, DER-encoded signature
 22 | # Output is a 64-byte hex-encoded signature
 23 | def derSigToHexSig(s):
 24 |     s, junk = ecdsa.der.remove_sequence(s.decode('hex'))
 25 |     if junk != '':
 26 |         print 'JUNK', junk.encode('hex')
 27 |     assert(junk == '')
 28 |     x, s = ecdsa.der.remove_integer(s)
 29 |     y, s = ecdsa.der.remove_integer(s)
 30 |     return '%064x%064x' % (x, y)
 31 | 
 32 | # Input is hex string
 33 | def privateKeyToPublicKey(s):
 34 |     sk = ecdsa.SigningKey.from_string(s.decode('hex'), curve=ecdsa.SECP256k1)
 35 |     vk = sk.verifying_key
 36 |     return ('\04' + sk.verifying_key.to_string()).encode('hex')
 37 | 
 38 | # Input is hex string
 39 | def keyToAddr(s):
 40 |     return pubKeyToAddr(privateKeyToPublicKey(s))
 41 | 
 42 | def pubKeyToAddr(s):
 43 |     ripemd160 = hashlib.new('ripemd160')
 44 |     ripemd160.update(hashlib.sha256(s.decode('hex')).digest())
 45 |     return utils.base58CheckEncode(0, ripemd160.digest())
 46 | 
 47 | def addrHashToScriptPubKey(b58str):
 48 |     assert(len(b58str) == 34)
 49 |     # 76     A9      14 (20 bytes)                                 88             AC
 50 |     return '76a914' + utils.base58CheckDecode(b58str).encode('hex') + '88ac'
 51 | 
 52 |     
 53 | class TestKey(unittest.TestCase):
 54 | 
 55 |     def test_privateKeyToWif(self):
 56 |         w = privateKeyToWif("0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D")
 57 |         self.assertEqual(w, "5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ")
 58 | 
 59 |     def test_WifToPrivateKey(self):
 60 |         k = wifToPrivateKey("5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ")
 61 |         self.assertEqual(k.upper(), "0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D")
 62 | 
 63 |     def test_keyToAddr(self):
 64 |         a = keyToAddr("18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725")
 65 |         self.assertEqual(a, "16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM")
 66 | 
 67 |     def test_pairs1(self):
 68 |         #blockchain.info
 69 |         wallet_addr = "1EyBEhrriJeghX4iqATQEWDq38Ae8ubBJe"
 70 |         wallet_private = "8tnArBrrp4KHVjv8WA6HiX4ev56WDhqGA16XJCHJzhNH"
 71 |         wallet_key = utils.base256encode(utils.base58decode(wallet_private)).encode('hex')
 72 |         self.assertEqual(keyToAddr(wallet_key), wallet_addr)
 73 | 
 74 |         # can import into multibit
 75 |         bitcoin_qt = "5Jhw8B9J9QLaMmcBRfz7x8KkD9gwbNoyBMfWyANqiDwm3FFwgGC"
 76 |         wallet_key = utils.base58CheckDecode(bitcoin_qt).encode('hex')
 77 |         self.assertEqual(keyToAddr(wallet_key), wallet_addr)
 78 | 
 79 |         wallet_key = "754580de93eea21579441b58e0c9b09f54f6005fc71135f5cfac027394b22caa"
 80 |         self.assertEqual(keyToAddr(wallet_key), wallet_addr)
 81 | 
 82 |     def test_pairs2(self):
 83 |         #http://gobittest.appspot.com/Address
 84 |         # Cannot import into multibit
 85 |         wallet_private = "BB08A897EA1E422F989D36DE8D8186D8406BE25E577FD2A66976BF172325CDC9"
 86 |         wallet_addr = "1MZ1nxFpvUgaPYYWaLPkLGAtKjRqcCwbGh"
 87 |         self.assertEqual(keyToAddr(wallet_private), wallet_addr)
 88 | 
 89 |     def test_pairs3(self):
 90 |         # Can import into multibit
 91 |         # http://bitaddress.org
 92 |         wallet_private = "5J8PhneLEaL9qEPvW5voRgrELeXcmM12B6FbiA9wZAwDMnJMb2L"
 93 |         wallet_addr = "1Q2SuNLDXDtda7DPnBTocQWtUg1v4xZMrV"
 94 |         self.assertEqual(keyToAddr(utils.base58CheckDecode(wallet_private).encode('hex')), wallet_addr)
 95 |         
 96 |     def test_der(self):
 97 |         self.assertEqual(ecdsa.der.encode_sequence(
 98 |             ecdsa.der.encode_integer(0x123456),
 99 |             ecdsa.der.encode_integer(0x89abcd)).encode('hex'),
100 |                          "300b020312345602040089abcd")
101 |     def test_derSigToHexSig(self):
102 |         derSig = "304502204c01fee2d724fb2e34930c658f585d49be2f6ac87c126506c0179e6977716093022100faad0afd3ae536cfe11f83afaba9a8914fc0e70d4c6d1495333b2fb3df6e8cae"
103 |         self.assertEqual("4c01fee2d724fb2e34930c658f585d49be2f6ac87c126506c0179e6977716093faad0afd3ae536cfe11f83afaba9a8914fc0e70d4c6d1495333b2fb3df6e8cae",
104 |                          derSigToHexSig(derSig))
105 |    
106 | 
107 |         txn =          ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
108 |                         "8a47" +
109 |                         "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01" +
110 |                         "41" +
111 |                         "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55" +
112 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
113 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
114 |         myTxn_forSig = ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
115 |                         "1976a914" + "167c74f7491fe552ce9e1912810a984355b8ee07" + "88ac" +
116 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
117 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000" +
118 |                         "01000000")
119 |         public_key =    "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55"
120 |         hashToSign = hashlib.sha256(hashlib.sha256(myTxn_forSig.decode('hex')).digest()).digest().encode('hex')
121 |         sig_der =       "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01"[:-2]
122 |         sig = derSigToHexSig(sig_der)
123 | 
124 |         vk = ecdsa.VerifyingKey.from_string(public_key[2:].decode('hex'), curve=ecdsa.SECP256k1)
125 |         self.assertEquals(vk.verify_digest(sig.decode('hex'), hashToSign.decode('hex')), True)
126 |         #OP_DUP OP_HASH160 167c74f7491fe552ce9e1912810a984355b8ee07 OP_EQUALVERIFY OP_CHECKSIG
127 | 
128 | if __name__ == '__main__':
129 |     unittest.main()
130 | 


--------------------------------------------------------------------------------
/makeAddr.py:
--------------------------------------------------------------------------------
1 | import random, keyUtils
2 | 
3 | private_key = ''.join(['%x' % random.randrange(16) for x in range(0, 64)])
4 | print keyUtils.privateKeyToWif(private_key)
5 | print keyUtils.keyToAddr(private_key)
6 | 
7 | 


--------------------------------------------------------------------------------
/makeTransaction.py:
--------------------------------------------------------------------------------
 1 | import utils
 2 | import keyUtils
 3 | import txnUtils
 4 | 
 5 | 
 6 | privateKey = keyUtils.wifToPrivateKey("5HusYj2b2x4nroApgfvaSfKYZhRbKFH41bVyPooymbC6KfgSXdD") #1MMMM
 7 | 
 8 | signed_txn = txnUtils.makeSignedTransaction(privateKey,
 9 |         "81b4c832d70cb56ff957589752eb4125a4cab78a25a8fc52d6a09e5bd4404d48", # output (prev) transaction hash
10 |         0, # sourceIndex
11 |         keyUtils.addrHashToScriptPubKey("1MMMMSUb1piy2ufrSguNUdFmAcvqrQF8M5"),
12 |         [[91234, #satoshis
13 |         keyUtils.addrHashToScriptPubKey("1KKKK6N21XKo48zWKuQKXdvSsCf95ibHFa")]]
14 |         )
15 |     
16 | txnUtils.verifyTxnSignature(signed_txn)
17 | print 'SIGNED TXN', signed_txn
18 | 


--------------------------------------------------------------------------------
/mine.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | import struct
 3 | import time
 4 | 
 5 | 
 6 | # block 272784
 7 | # http://blockexplorer.com/block/0000000000000003ce284b6b4244552242e8e64efc2df1bdadb93f392ade1a35
 8 | 
 9 | ver = 2
10 | prev_block = "000000000000000027d4d014f6245170390ea904cec17d1761021d28049c20b9"
11 | mrkl_root = "57ebfd5b7fed40fc07120b1b03550ea1069d74b2dfc8cf81dc25bb48cee4221f"
12 | time_ = 1389075720 # Mon Jan 06 22:22:00 2014
13 | bits = 419628831
14 | p = ''
15 | 
16 | # https://en.bitcoin.it/wiki/Difficulty
17 | exp = bits >> 24
18 | mant = bits & 0xffffff
19 | target = mant * (1<<(8*(exp - 3)))
20 | target_hexstr = '%064x' % target
21 | print target_hexstr
22 | target_str = target_hexstr.decode('hex')
23 | print repr(target_str)
24 | 
25 | nonce = 100000000
26 | while 1:
27 |     nonce += 1
28 |     header = ( struct.pack("<L", ver) + prev_block.decode('hex')[::-1] +
29 |           mrkl_root.decode('hex')[::-1] + struct.pack("<LLL", time_, bits, nonce))
30 | 
31 |     hash = hashlib.sha256(hashlib.sha256(header).digest()).digest()
32 | 
33 |     if nonce == 0:
34 |         print nonce, hash[::-1].encode('hex_codec')
35 | 
36 | 
37 |     if hash[::-1].encode('hex_codec').startswith(p):
38 |         print nonce, hash[::-1].encode('hex_codec')
39 |         p += '0'
40 |     if hash[::-1] < target_str:
41 |         print 'done', nonce
42 |         break
43 | 
44 | 
45 | 
46 | 


--------------------------------------------------------------------------------
/minimalPeerConnection.py:
--------------------------------------------------------------------------------
 1 | import struct
 2 | import socket
 3 | 
 4 | import utils
 5 | import msgUtils
 6 | 
 7 | 
 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9 | sock.connect(("184.155.9.47", 8333))
10 | 
11 | sock.send(msgUtils.getVersionMsg())
12 | 
13 | while 1:
14 |     sock.recv(1000) # Throw away data
15 |     print 'got packet'
16 |     
17 | 


--------------------------------------------------------------------------------
/minimalSendTxn.py:
--------------------------------------------------------------------------------
 1 | import msgUtils
 2 | import socket
 3 | 
 4 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5 | sock.connect(("97.88.151.164", 8333))
 6 | 
 7 | sock.send(msgUtils.getVersionMsg())
 8 | sock.recv(1000) # receive version
 9 | sock.recv(1000) # receive verack
10 | sock.send(msgUtils.getTxMsg("0100000001484d40d45b9ea0d652fca8258ab7caa42541eb52975857f96fb50cd732c8b481000000008a47304402202cb265bf10707bf49346c3515dd3d16fc454618c58ec0a0ff448a676c54ff71302206c6624d762a1fcef4618284ead8f08678ac05b13c84235f1654e6ad168233e8201410414e301b2328f17442c0b8310d787bf3d8a404cfbd0704f135b6ad4b2d3ee751310f981926e53a6e8c39bd7d3fefd576c543cce493cbac06388f2651d1aacbfcdffffffff0162640100000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac00000000".decode('hex')))
11 | 
12 | 


--------------------------------------------------------------------------------
/msgUtils.py:
--------------------------------------------------------------------------------
  1 | import hashlib
  2 | import random
  3 | import struct
  4 | import time
  5 | import socket
  6 | import unittest
  7 | 
  8 | import utils
  9 | 
 10 |     
 11 | #https://en.bitcoin.it/wiki/Protocol_specification#version
 12 | magic = 0xd9b4bef9
 13 | 
 14 | def makeMessage(magic, command, payload):
 15 |     checksum = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[0:4]
 16 |     return struct.pack('<L12sL4s', magic, command, len(payload), checksum) + payload
 17 | 
 18 | addrCount = 0 
 19 | def processChunk(header, payload):
 20 |     """ Processes a response from a peer."""
 21 |     magic, cmd, payload_len, checksum = struct.unpack('<L12sL4s', header)
 22 |     if len(payload) != payload_len:
 23 |         print 'BAD PAYLOAD LENGTH', len(payload), payload_len
 24 |         
 25 |     cmd = cmd.replace('\0', '') # Remove null termination
 26 |     print '--- %s ---' % cmd
 27 |     
 28 |     if cmd == 'version':
 29 |         version, services, timestamp, addr_recv, addr_from, nonce = struct.unpack('<LQQ26s26sQ', payload[:80])
 30 |         agent, agent_len = utils.processVarStr(payload[80:])
 31 | 
 32 |         start_height = struct.unpack('<L', payload[80 + agent_len:84 + agent_len])[0]
 33 |         print '%d %x %x %s %s %x %s %x' % (
 34 |             version, services, timestamp, utils.processAddr(addr_recv), utils.processAddr(addr_from),
 35 |             nonce, agent, start_height)
 36 |     elif cmd == 'inv':
 37 |         count, offset = utils.processVarInt(payload)
 38 |         result = []
 39 |         for i in range(0, count):
 40 |             type, hash = struct.unpack('<L32s', payload[offset:offset+36])
 41 |             # Note: hash is reversed
 42 |             print type, hash[::-1].encode('hex')
 43 |             if type == 2:
 44 |                 sys.exit(0)
 45 |             result.append([type, hash])
 46 |             offset += 36
 47 |         print '---\n'
 48 |         return result
 49 |     elif cmd == 'addr':
 50 |         global addrCount
 51 |         count, offset = utils.processVarInt(payload)
 52 |         for i in range(0, count):
 53 |             timestamp, = struct.unpack('<L', payload[offset:offset+4])
 54 |             addr = utils.processAddr(payload[offset+4:offset+30])
 55 |             offset += 30
 56 |             print addrCount, time.ctime(timestamp), addr
 57 |             addrCount += 1
 58 |     else:
 59 |         dump(payload)
 60 |     print '---\n'
 61 | 
 62 | 
 63 | def dump(s):
 64 |     print ':'.join(x.encode('hex') for x in s)
 65 | 
 66 | 
 67 | def getVersionMsg():
 68 |     # version(4), services(8), timestamp(8), addr_me(26), addr_you(26), nonce(8)
 69 |     # sub_version_num (var_str), start_height(4)
 70 |     version = 60002
 71 |     services = 1
 72 |     timestamp = int(time.time())
 73 |     addr_me = utils.netaddr(socket.inet_aton("127.0.0.1"), 8333)
 74 |     addr_you = utils.netaddr(socket.inet_aton("127.0.0.1"), 8333)
 75 |     nonce = random.getrandbits(64)
 76 |     sub_version_num = utils.varstr('')
 77 |     start_height = 0
 78 | 
 79 |     payload = struct.pack('<LQQ26s26sQsL', version, services, timestamp, addr_me,
 80 |         addr_you, nonce, sub_version_num, start_height)
 81 |     return makeMessage(magic, 'version', payload)
 82 | 
 83 | def getGetblockMsg():
 84 |     genesis = "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
 85 |     genesis_str = genesis.decode('hex')[::-1] # reversed
 86 |     recent = "000000000000000592f4797aab7c1fd891a4cacd300d2115f25fa5afab547cdf"
 87 |     recent_str = recent.decode('hex')[::-1] # reversed
 88 | 
 89 |     hash_stop_str = '\0' * 32
 90 |     payload_getblocks = struct.pack('<L', version) + utils.varint(2) + recent_str + genesis_str + hash_stop_str
 91 |     return makeMessage(magic, 'getblocks', payload_getblocks)
 92 | 
 93 | def getGetdataMsg():
 94 |     payload_getdata = utils.varint(1) + struct.pack('<L', 2) + recent_str
 95 |     return makeMessage(magic, 'getdata', payload_getdata)
 96 | 
 97 | def getInvMsg():
 98 |     inv_hash = "235402020007000592f4797a567c1fd89144cacd300d2115f12fa53fab547abc"
 99 |     payload_inv = utils.varint(1) + struct.pack('<L', 2) + inv_hash.decode('hex')[::-1]
100 |     return makeMessage(magic, 'inv', payload_inv)
101 | 
102 | def getTxMsg(payload):
103 |     return makeMessage(magic, 'tx', payload)
104 | 
105 | def getAddrMsg():
106 |     return makeMessage(magic, 'getaddr', '')
107 | 
108 | class TestParsing(unittest.TestCase):        
109 |     def test_processChunk(self):
110 |         header = ('\xf9\xbe\xb4\xd9\x76\x65\x72\x73\x69\x6f\x6e\x00\x00\x00\x00\x00' +
111 |                 '\x66\x00\x00\x00\x85\xe6\xaa\x94')
112 |         payload = ('\x71\x11\x01\x00\x01\x00\x00\x00' +
113 |                '\x00\x00\x00\x00\xa2\x31\xa0\x52\x00\x00\x00\x00\x01\x00\x00\x00' +
114 |                '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff' +
115 |                '\x6c\x51\xe0\xee\xd8\x73\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
116 |                '\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x62\x91\x98\x16\x20\x8d' +
117 |                '\xf4\x7d\x37\xbf\xe4\xe7\x1f\xd2\x11\x2f\x53\x61\x74\x6f\x73\x68' +
118 |                '\x69\x3a\x30\x2e\x38\x2e\x32\x2e\x32\x2f\x02\x2b\x04\x00')
119 |         processChunk(header, payload)
120 | 
121 |     def test_processInv(self):
122 |         header = ('\xf9\xbe\xb4\xd9\x69\x6e\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00' +
123 |                   '\x25\x00\x00\x00\x73\x3b\xf4\x95')
124 |         payload = ('\x01\x01\x00\x00\x00\xd4\xe5\xc2' +
125 |                    '\x8b\x09\x45\x05\xce\xec\x7c\x61\x34\xd1\xbd\x16\x80\x69\xc8\xc9' +
126 |                    '\xc3\x31\x93\xb5\x87\x27\xd9\xda\x7d\xa2\x80\x23\x20')
127 |         chunks = processChunk(header, payload)
128 |         self.assertEqual(len(chunks), 1)
129 |         self.assertEqual(chunks[0][0], 1) # MSG_TX
130 |         self.assertEqual(chunks[0][1], ('\xd4\xe5\xc2\x8b\x09\x45\x05\xce\xec\x7c\x61\x34\xd1\xbd\x16\x80' +
131 | '\x69\xc8\xc9\xc3\x31\x93\xb5\x87\x27\xd9\xda\x7d\xa2\x80\x23\x20'))
132 |         
133 | 
134 | if __name__ == '__main__':
135 |     unittest.main()
136 |     
137 | 


--------------------------------------------------------------------------------
/sendBitcoinTransaction.py:
--------------------------------------------------------------------------------
 1 | import struct
 2 | import socket
 3 | 
 4 | import utils
 5 | import msgUtils
 6 | 
 7 | 
 8 | sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9 | #sock.connect(("50.151.108.133", 8333))
10 | #sock.connect(("64.237.43.178", 8333))
11 | sock.connect(("24.255.210.44", 8333))
12 | 
13 | sock.send(msgUtils.getVersionMsg())
14 | 
15 | want = 0
16 | buf = ''
17 | 
18 | step = 0
19 | while 1:
20 |     header = sock.recv(24)
21 |     if len(header) == 0: break
22 |     magic, cmd, payload_len, checksum = struct.unpack('L12sL4s', header)
23 |     buf = ''
24 |     while payload_len > 0:
25 |         chunk = sock.recv(payload_len)
26 |         if len(chunk) == 0: break
27 |         buf += chunk
28 |         payload_len -= len(chunk)
29 |         print 'got chunk of', len(chunk)
30 |     msgUtils.processChunk(header, buf)
31 |         
32 |     #if step == 0:
33 |     #   sock.send(msg_getblocks)
34 |     step += 1
35 | 
36 |     if step == 5:
37 |         msg = msgUtils.getAddrMsg()
38 |         sock.send(msg)
39 |         print 'SENT', msg.encode('hex')
40 | 
41 | 
42 | 
43 | 
44 | 


--------------------------------------------------------------------------------
/txnUtils.py:
--------------------------------------------------------------------------------
  1 | # https://pypi.python.org/pypi/ecdsa/0.10
  2 | 
  3 | import ecdsa
  4 | import hashlib
  5 | import struct
  6 | import unittest
  7 | 
  8 | import utils
  9 | import keyUtils
 10 | 
 11 | # Makes a transaction from the inputs
 12 | # outputs is a list of [redemptionSatoshis, outputScript]
 13 | def makeRawTransaction(outputTransactionHash, sourceIndex, scriptSig, outputs):
 14 |     def makeOutput(data):
 15 |         redemptionSatoshis, outputScript = data
 16 |         return (struct.pack("<Q", redemptionSatoshis).encode('hex') +
 17 |         '%02x' % len(outputScript.decode('hex')) + outputScript)
 18 |     formattedOutputs = ''.join(map(makeOutput, outputs))
 19 |     return (
 20 |         "01000000" + # 4 bytes version
 21 |         "01" + # varint for number of inputs
 22 |         outputTransactionHash.decode('hex')[::-1].encode('hex') + # reverse outputTransactionHash
 23 |         struct.pack('<L', sourceIndex).encode('hex') +
 24 |         '%02x' % len(scriptSig.decode('hex')) + scriptSig +
 25 |         "ffffffff" + # sequence
 26 |         "%02x" % len(outputs) + # number of outputs
 27 |         formattedOutputs +
 28 |         "00000000" # lockTime
 29 |         )
 30 | 
 31 | # Returns [first, sig, pub, rest]
 32 | def parseTxn(txn):
 33 |     first = txn[0:41*2]
 34 |     scriptLen = int(txn[41*2:42*2], 16)
 35 |     script = txn[42*2:42*2+2*scriptLen]
 36 |     sigLen = int(script[0:2], 16)
 37 |     sig = script[2:2+sigLen*2]
 38 |     pubLen = int(script[2+sigLen*2:2+sigLen*2+2], 16)
 39 |     pub = script[2+sigLen*2+2:]
 40 |             
 41 |     assert(len(pub) == pubLen*2)
 42 |     rest = txn[42*2+2*scriptLen:]
 43 |     return [first, sig, pub, rest]         
 44 | 
 45 | # Substitutes the scriptPubKey into the transaction, appends SIGN_ALL to make the version
 46 | # of the transaction that can be signed
 47 | def getSignableTxn(parsed):
 48 |     first, sig, pub, rest = parsed
 49 |     inputAddr = utils.base58CheckDecode(keyUtils.pubKeyToAddr(pub))
 50 |     return first + "1976a914" + inputAddr.encode('hex') + "88ac" + rest + "01000000"
 51 | 
 52 | # Verifies that a transaction is properly signed, assuming the generated scriptPubKey matches
 53 | # the one in the previous transaction's output
 54 | def verifyTxnSignature(txn):                    
 55 |     parsed = parseTxn(txn)      
 56 |     signableTxn = getSignableTxn(parsed)
 57 |     hashToSign = hashlib.sha256(hashlib.sha256(signableTxn.decode('hex')).digest()).digest().encode('hex')
 58 |     assert(parsed[1][-2:] == '01') # hashtype
 59 |     sig = keyUtils.derSigToHexSig(parsed[1][:-2])
 60 |     public_key = parsed[2]
 61 |     vk = ecdsa.VerifyingKey.from_string(public_key[2:].decode('hex'), curve=ecdsa.SECP256k1)
 62 |     assert(vk.verify_digest(sig.decode('hex'), hashToSign.decode('hex')))
 63 | 
 64 | def makeSignedTransaction(privateKey, outputTransactionHash, sourceIndex, scriptPubKey, outputs):
 65 |     myTxn_forSig = (makeRawTransaction(outputTransactionHash, sourceIndex, scriptPubKey, outputs)
 66 |          + "01000000") # hash code
 67 | 
 68 |     s256 = hashlib.sha256(hashlib.sha256(myTxn_forSig.decode('hex')).digest()).digest()
 69 |     sk = ecdsa.SigningKey.from_string(privateKey.decode('hex'), curve=ecdsa.SECP256k1)
 70 |     sig = sk.sign_digest(s256, sigencode=ecdsa.util.sigencode_der) + '\01' # 01 is hashtype
 71 |     pubKey = keyUtils.privateKeyToPublicKey(privateKey)
 72 |     scriptSig = utils.varstr(sig).encode('hex') + utils.varstr(pubKey.decode('hex')).encode('hex')
 73 |     signed_txn = makeRawTransaction(outputTransactionHash, sourceIndex, scriptSig, outputs)
 74 |     verifyTxnSignature(signed_txn)
 75 |     return signed_txn
 76 |     
 77 | class TestTxnUtils(unittest.TestCase):
 78 | 
 79 |     def test_verifyParseTxn(self):
 80 |         txn =          ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
 81 |                         "8a47" +
 82 |                         "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01" +
 83 |                         "41" +
 84 |                         "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55" +
 85 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
 86 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
 87 | 
 88 | 
 89 |         parsed = parseTxn(txn)
 90 |         self.assertEqual(parsed[0], "0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000")
 91 |         self.assertEqual(parsed[1], "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01")
 92 |         self.assertEqual(parsed[2], "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55")
 93 |         self.assertEqual(parsed[3], "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
 94 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
 95 | 
 96 |     def test_verifySignableTxn(self):
 97 |         txn =          ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
 98 |                         "8a47" +
 99 |                         "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01" +
100 |                         "41" +
101 |                         "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55" +
102 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
103 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
104 | 
105 |         parsed = parseTxn(txn)      
106 |         myTxn_forSig = ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
107 |                         "1976a914" + "167c74f7491fe552ce9e1912810a984355b8ee07" + "88ac" +
108 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
109 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000" +
110 |                         "01000000")
111 |         signableTxn = getSignableTxn(parsed)
112 |         self.assertEqual(signableTxn, myTxn_forSig)
113 | 
114 |     def test_verifyTxn(self):
115 |         txn =          ("0100000001a97830933769fe33c6155286ffae34db44c6b8783a2d8ca52ebee6414d399ec300000000" +
116 |                         "8a47" +
117 |                         "304402202c2e1a746c556546f2c959e92f2d0bd2678274823cc55e11628284e4a13016f80220797e716835f9dbcddb752cd0115a970a022ea6f2d8edafff6e087f928e41baac01" +
118 |                         "41" +
119 |                         "04392b964e911955ed50e4e368a9476bc3f9dcc134280e15636430eb91145dab739f0d68b82cf33003379d885a0b212ac95e9cddfd2d391807934d25995468bc55" +
120 |                         "ffffffff02015f0000000000001976a914c8e90996c7c6080ee06284600c684ed904d14c5c88ac204e000000000000" +
121 |                         "1976a914348514b329fda7bd33c7b2336cf7cd1fc9544c0588ac00000000")
122 | 
123 |         verifyTxnSignature(txn)
124 | 
125 |     def test_makeRawTransaction(self):
126 |         #http://bitcoin.stackexchange.com/questions/3374/how-to-redeem-a-basic-tx
127 |         txn = makeRawTransaction(
128 |             "f2b3eb2deb76566e7324307cd47c35eeb88413f971d88519859b1834307ecfec", # output transaction hash
129 |             1, # sourceIndex
130 |             "76a914010966776006953d5567439e5e39f86a0d273bee88ac", # scriptSig
131 |             [[99900000, #satoshis
132 |             "76a914097072524438d003d23a2f23edb65aae1bb3e46988ac"]], # outputScript
133 |             ) + "01000000" # hash code type
134 |         self.assertEqual(txn,
135 |             "0100000001eccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2" +
136 |             "010000001976a914010966776006953d5567439e5e39f86a0d273bee88acffffffff" +
137 |             "01605af405000000001976a914097072524438d003d23a2f23edb65aae1bb3e46988ac" +
138 |             "0000000001000000")
139 |    
140 |     def test_makeSignedTransaction(self):
141 |         # Transaction from
142 |         # https://blockchain.info/tx/901a53e7a3ca96ed0b733c0233aad15f11b0c9e436294aa30c367bf06c3b7be8
143 |         # From 133t to 1KKKK
144 |         privateKey = keyUtils.wifToPrivateKey("5Kb6aGpijtrb8X28GzmWtbcGZCG8jHQWFJcWugqo3MwKRvC8zyu") #133t
145 | 
146 |         signed_txn = makeSignedTransaction(privateKey,
147 |             "c39e394d41e6be2ea58c2d3a78b8c644db34aeff865215c633fe6937933078a9", # output (prev) transaction hash
148 |             0, # sourceIndex
149 |             keyUtils.addrHashToScriptPubKey("133txdxQmwECTmXqAr9RWNHnzQ175jGb7e"),
150 |             [[24321, #satoshis
151 |             keyUtils.addrHashToScriptPubKey("1KKKK6N21XKo48zWKuQKXdvSsCf95ibHFa")],
152 |              [20000,            keyUtils.addrHashToScriptPubKey("15nhZbXnLMknZACbb3Jrf1wPCD9DWAcqd7")]]
153 |             )
154 | 
155 |         verifyTxnSignature(signed_txn)
156 | 
157 | if __name__ == '__main__':
158 |     unittest.main()
159 | 


--------------------------------------------------------------------------------
/utils.py:
--------------------------------------------------------------------------------
  1 | import hashlib
  2 | import struct
  3 | import unittest
  4 | 
  5 | b58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
  6 | 
  7 | # Returns byte string value, not hex string
  8 | def varint(n):
  9 |     if n < 0xfd:
 10 |         return struct.pack('<B', n)
 11 |     elif n < 0xffff:
 12 |         return struct.pack('<cH', '\xfd', n)
 13 |     elif n < 0xffffffff:
 14 |         return struct.pack('<cL', '\xfe', n)
 15 |     else:
 16 |         return struct.pack('<cQ', '\xff', n)
 17 | 
 18 | # Takes and returns byte string value, not hex string
 19 | def varstr(s):
 20 |     return varint(len(s)) + s
 21 | 
 22 | # 60002
 23 | def netaddr(ipaddr, port):
 24 |     services = 1
 25 |     return (struct.pack('<Q12s', services, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff') +
 26 |                        struct.pack('>4sH', ipaddr, port))
 27 | # return value, len
 28 | def processVarInt(payload):
 29 |     n0 = ord(payload[0])
 30 |     if n0 < 0xfd:
 31 |         return [n0, 1]
 32 |     elif n0 == 0xfd:
 33 |         return [struct.unpack('<H', payload[1:3])[0], 3]
 34 |     elif n0 == 0xfe:
 35 |         return [struct.unpack('<L', payload[1:5])[0], 5]
 36 |     else:
 37 |         return [struct.unpack('<Q', payload[1:5])[0], 7]
 38 | 
 39 | # return value, len
 40 | def processVarStr(payload):
 41 |     n, length = processVarInt(payload)
 42 |     return [payload[length:length+n], length + n]
 43 | 
 44 | # takes 26 byte input, returns string  
 45 | def processAddr(payload):
 46 |     assert(len(payload) >= 26)
 47 |     return '%d.%d.%d.%d:%d' % (ord(payload[20]), ord(payload[21]),
 48 |                                ord(payload[22]), ord(payload[23]),
 49 |                                struct.unpack('!H', payload[24:26])[0])
 50 | 
 51 | 
 52 | def base58encode(n):
 53 |     result = ''
 54 |     while n > 0:
 55 |         result = b58[n%58] + result
 56 |         n /= 58
 57 |     return result
 58 | 
 59 | def base58decode(s):
 60 |     result = 0
 61 |     for i in range(0, len(s)):
 62 |         result = result * 58 + b58.index(s[i])
 63 |     return result
 64 | 
 65 | def base256encode(n):
 66 |     result = ''
 67 |     while n > 0:
 68 |         result = chr(n % 256) + result
 69 |         n /= 256
 70 |     return result
 71 | 
 72 | def base256decode(s):
 73 |     result = 0
 74 |     for c in s:
 75 |         result = result * 256 + ord(c)
 76 |     return result
 77 | 
 78 | def countLeadingChars(s, ch):
 79 |     count = 0
 80 |     for c in s:
 81 |         if c == ch:
 82 |             count += 1
 83 |         else:
 84 |             break
 85 |     return count
 86 | 
 87 | # https://en.bitcoin.it/wiki/Base58Check_encoding
 88 | def base58CheckEncode(version, payload):
 89 |     s = chr(version) + payload
 90 |     checksum = hashlib.sha256(hashlib.sha256(s).digest()).digest()[0:4]
 91 |     result = s + checksum
 92 |     leadingZeros = countLeadingChars(result, '\0')
 93 |     return '1' * leadingZeros + base58encode(base256decode(result))
 94 | 
 95 | def base58CheckDecode(s):
 96 |     leadingOnes = countLeadingChars(s, '1')
 97 |     s = base256encode(base58decode(s))
 98 |     result = '\0' * leadingOnes + s[:-4]
 99 |     chk = s[-4:]
100 |     checksum = hashlib.sha256(hashlib.sha256(result).digest()).digest()[0:4]
101 |     assert(chk == checksum)
102 |     version = result[0]
103 |     return result[1:]
104 | 
105 | class TestUtils(unittest.TestCase):
106 |     def test_varint(self):
107 |         self.assertEqual(varint(0x42), '\x42')
108 |         self.assertEqual(varint(0x123), '\xfd\x23\x01')
109 |         self.assertEqual(varint(0x12345678), '\xfe\x78\x56\x34\x12')
110 |         self.assertEqual(processVarInt(varint(0x42)), [0x42, 1])
111 |         self.assertEqual(processVarInt(varint(0x1234)), [0x1234, 3])
112 | 
113 |     def test_varstr(self):
114 |         self.assertEqual(varstr('abc'), '\x03abc')
115 |         self.assertEqual(processVarStr('\x03abc'), ['abc', 4])
116 | 
117 |     def test_processAddr(self):
118 |         self.assertEqual(processAddr('x'*20 + '\x62\x91\x98\x16\x20\x8d'),
119 |                          '98.145.152.22:8333')
120 | 
121 |     def test_countLeadingCharacters(self):
122 |         self.assertEqual(countLeadingChars('a\0bcd\0', '\0'), 0)
123 |         self.assertEqual(countLeadingChars('\0\0a\0bcd\0', '\0'), 2)        
124 |         self.assertEqual(countLeadingChars('1a\0bcd\0', '1'), 1)
125 | 
126 |     def test_base256(self):
127 |         self.assertEqual(base256encode(base256decode('abc')), 'abc')
128 |         self.assertEqual(base256encode(0x4142), 'AB')
129 |         self.assertEqual(base256decode('AB'), 0x4142)
130 | 
131 |     def test_base58(self):
132 |         self.assertEqual(base58encode(base58decode('abc')), 'abc')
133 |         self.assertEqual(base58decode('121'), 58)
134 |         self.assertEqual(base58decode('5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ'),
135 |             0x800C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D507A5B8D)
136 | 
137 |     def test_base58check(self):
138 |         self.assertEqual(base58CheckDecode(base58CheckEncode(42, 'abc')), 'abc')
139 |         self.assertEqual(base58CheckDecode(base58CheckEncode(0, '\0\0abc')), '\0\0abc')
140 |         s = base256encode(0x0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D)
141 |         b = base58CheckEncode(0x80, s)
142 |         self.assertEqual(b, "5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ")
143 | 
144 | if __name__ == '__main__':
145 |     unittest.main()
146 | 


--------------------------------------------------------------------------------