--- /dev/null
+#
+# Workalike python implementation of Bitcoin's CDataStream class.
+#
+import struct
+import StringIO
+import mmap
+
+class SerializationError(Exception):
+ """ Thrown when there's a problem deserializing or serializing """
+
+class BCDataStream(object):
+ def __init__(self):
+ self.input = None
+ self.read_cursor = 0
+
+ def clear(self):
+ self.input = None
+ self.read_cursor = 0
+
+ def write(self, bytes): # Initialize with string of bytes
+ if self.input is None:
+ self.input = bytes
+ else:
+ self.input += bytes
+
+ def map_file(self, file, start): # Initialize with bytes from file
+ self.input = mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ)
+ self.read_cursor = start
+ def seek_file(self, position):
+ self.read_cursor = position
+ def close_file(self):
+ self.input.close()
+
+ def read_string(self):
+ # Strings are encoded depending on length:
+ # 0 to 252 : 1-byte-length followed by bytes (if any)
+ # 253 to 65,535 : byte'253' 2-byte-length followed by bytes
+ # 65,536 to 4,294,967,295 : byte '254' 4-byte-length followed by bytes
+ # ... and the Bitcoin client is coded to understand:
+ # greater than 4,294,967,295 : byte '255' 8-byte-length followed by bytes of string
+ # ... but I don't think it actually handles any strings that big.
+ if self.input is None:
+ raise SerializationError("call write(bytes) before trying to deserialize")
+
+ try:
+ length = self.read_compact_size()
+ except IndexError:
+ raise SerializationError("attempt to read past end of buffer")
+
+ return self.read_bytes(length)
+
+ def write_string(self, string):
+ # Length-encoded as with read-string
+ self.write_compact_size(len(string))
+ self.write(string)
+
+ def read_bytes(self, length):
+ try:
+ result = self.input[self.read_cursor:self.read_cursor+length]
+ self.read_cursor += length
+ return result
+ except IndexError:
+ raise SerializationError("attempt to read past end of buffer")
+
+ return ''
+
+ def read_boolean(self): return self.read_bytes(1)[0] != chr(0)
+ def read_int16(self): return self._read_num('<h')
+ def read_uint16(self): return self._read_num('<H')
+ def read_int32(self): return self._read_num('<i')
+ def read_uint32(self): return self._read_num('<I')
+ def read_int64(self): return self._read_num('<q')
+ def read_uint64(self): return self._read_num('<Q')
+
+ def write_boolean(self, val): return self.write(chr(1) if val else chr(0))
+ def write_int16(self, val): return self._write_num('<h', val)
+ def write_uint16(self, val): return self._write_num('<H', val)
+ def write_int32(self, val): return self._write_num('<i', val)
+ def write_uint32(self, val): return self._write_num('<I', val)
+ def write_int64(self, val): return self._write_num('<q', val)
+ def write_uint64(self, val): return self._write_num('<Q', val)
+
+ def read_compact_size(self):
+ size = ord(self.input[self.read_cursor])
+ self.read_cursor += 1
+ if size == 253:
+ size = self._read_num('<H')
+ elif size == 254:
+ size = self._read_num('<I')
+ elif size == 255:
+ size = self._read_num('<Q')
+ return size
+
+ def write_compact_size(self, size):
+ if size < 0:
+ raise SerializationError("attempt to write size < 0")
+ elif size < 253:
+ self.write(chr(size))
+ elif size < 2**16:
+ self.write('\xfd')
+ self._write_num('<H', size)
+ elif size < 2**32:
+ self.write('\xfe')
+ self._write_num('<I', size)
+ elif size < 2**64:
+ self.write('\xff')
+ self._write_num('<Q', size)
+
+ def _read_num(self, format):
+ (i,) = struct.unpack_from(format, self.input, self.read_cursor)
+ self.read_cursor += struct.calcsize(format)
+ return i
+
+ def _write_num(self, format, num):
+ s = struct.pack(format, num)
+ self.write(s)
--- /dev/null
+Copyright (c) 2010 Gavin Andresen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- /dev/null
+Most of this information is now at the Protocol Specification page at the bitcoin wiki:
+ https://en.bitcoin.it/wiki/Protocol_specification
+
+One of these days I might check this document against the wiki, add any missing information to the wiki, and remove the information below.
+
+
+Transaction dissection notes:
+-----------------------------
+
+My first two transactions look like this:
+
+==WalletTransaction== f240...2582
+Merkle hashBlock: 6d40...0000
+1 tx in, 1 out
+['TxIn: prev(e9d4...d2f4:0) pubkey: 1Lfic7L3z7xUbxRDvMNFiE3QxKRmSSrvEH sig: 72:3045...1a01 65:0403...7b86']
+['TxOut: value: 500.00 pubkey: 19vcWM6EEbQHVdN2W8NXv9ySgsPjbZ6gU3 Script: DUP HASH160 20:61e4...614c EQUALVERIFY CHECKSIG']
+ timeReceived:Thu May 27 14:25:48 2010 fromMe:True spent:True
+
+==WalletTransaction== f961...4472
+Merkle hashBlock: 7707...0000
+1 tx in, 2 out
+['TxIn: prev(f240...2582:0) pubkey: 19vcWM6EEbQHVdN2W8NXv9ySgsPjbZ6gU3 sig: 72:3045...a801 65:04a6...a541']
+['TxOut: value: 142.40 pubkey: 15F9miF9egehbeCiPKVSJSwgw5J96my7Rf Script: DUP HASH160 20:2e8d...5179 EQUALVERIFY CHECKSIG', 'TxOut: value: 357.60 pubkey: 1Av6tJSFv3bZvUfaALm4TQZmYvdeuHcbUb Script: DUP HASH160 20:6cc4...1755 EQUALVERIFY CHECKSIG']
+ timeReceived:Fri May 28 13:55:23 2010 fromMe:True spent:True
+
+So: whoever has sending bc address 1Lfic7L3z7xUbxRDvMNFiE3QxKRmSSrvEH sent 500 bitcoins to
+my 19vcWM6EEbQHVdN2W8NXv9ySgsPjbZ6gU3 receiving address.
+
+I then sent 142.40 to bcaddress 15F9miF9egehbeCiPKVSJSwgw5J96my7Rf.
+And got 357.60 in change (Bitcoin created a new address for the change: 1Av6tJSFv3bZvUfaALm4TQZmYvdeuHcbUb)
+
+Spending generated coins looks different:
+
+Transaction 6403...cc0e
+['TxIn: COIN GENERATED coinbase:0464ba0e1c010a']
+['TxOut: value: 50.00 pubkey: 1Cpr8WJYa5igdo8AtPS24hfVLkk6ANZSWN Script: 65:0442...11c2 CHECKSIG']
+
+Transaction db39...8dcd:
+['TxIn: COIN GENERATED coinbase:0464ba0e1c0130']
+['TxOut: value: 50.00 pubkey: 1LuamEE1rL1QAdgn48gGFD9T9mnqSeP17w Script: 65:04f2...e10f CHECKSIG']
+
+==WalletTransaction== 3860...f888
+['TxIn: prev(6403...cc0e:0) pubkey: (None) sig: 72:3045...f501', 'TxIn: prev(db39...8dcd:0) pubkey: (None) sig: 73:3046...9\
+601']
+['TxOut: value: 100.00 pubkey: 1BBWNxMqU2bTwSVeUDVKmNYJrWr4D1pBrf Script: DUP HASH160 20:6fad...ab90 EQUALVERIFY CHECKSIG']
+
+Here I received 100 bitcoins from two 50 COIN GENERATED transactions.
+
+
+blkindex.dat serialization notes:
+---------------------------------
+
+Keys beging with a serialized string, rest of key and value depend on that first string. Possibilities are:
+
+tx : key continues with uint256 transaction hash/id (32 bytes)
+ value is:
+ version : 32-bit unsigned int
+ CDiskTxPos : location of transaction (in the blk000N.dat files)
+ vector<CDiskTxPos> : location of transactions that spend this transaction's inputs
+
+blockindex : key continues with uint256 block hash (32 bytes)
+ value is serialized CDiskBlockIndex
+
+version : value is integer version number
+
+hashBestChain : value is 32-byte SHA256 hash of last block in the longest block chain.
+
+
+wallet.dat serialization notes:
+-------------------------------
+Berkely DB BTREE file (key-value pairs).
+
+Keys begin with a serialized string, rest of key and value depend on that first string. Possibilities are:
+
+name : key continues with 34-character Bitcoin "hash160" address
+ value is a simple string.
+
+tx : key continues with uint256 (32 bytes)
+ value is a serialized CTransaction+CMerkleTx+CWalletTx (see below for details)
+
+key : key continues with vector<unsigned char> that is public key
+ value is vector<unsigned char> that is private key (full 271-byte
+ OpenSSL representation)
+
+wkey : key continues with vector<unsigned char> that is public key
+ value is serialized CWalletKey:
+ vector<unsigned char> that is private key
+ int64 nTimeCreated
+ int64 nTimeExpires
+ string comment
+
+ckey : enCrypted key continues with vector<unsigned char> that is public key
+ value is vector<unsigned char> that is private key (32 byte private part,
+ not full 271-byte OpenSSL representation)
+
+mkey : master key continues with unsigned int that is ID of the master key
+ value is serialized CMasterKey:
+ vector<unsigned char> encrypted key
+ vector<unsigned char> encrypted salt
+ unsigned int indicating the method to derive key from password
+ unsigned int indicating the number of times the derivation algorithm should be iterated
+ vector<unsigned char> holding other parameters to the derivation algorithm
+
+defaultkey :
+ value is vector<unsigned char> default key
+
+version :
+ value is int version number
+
+setting : key continues with setting name, value depends on setting as follows:
+ addrIncoming : CAddress serialized
+ addrProxy : CAddress serialized
+ fGenerateBitcoins : 1-character (boolean)
+ fLimitProcessors : 1-character (boolean)
+ fMinimizeOnClose : 1-character (boolean)
+ fMinimizeToTray : 1-character (boolean)
+ fUseProxy : 1-character (boolean)
+ nLimitProcessors : int
+ nTransactionFee : int64
+
+
+Complex value type serialization:
+---------------------------------
+
+CDiskTxPos:
+ uint32 nFile : Which of the blk000*.dat files
+ uint32 nBlockPos : Byte position in file
+ uint32 nTxPos : Byte position in file
+
+CDiskBlockIndex:
+ int nVersion
+ uint256 hashNext
+ uint32 nFile : Which of the blk000*.dat files
+ uint32 nBlockPos : Byte position in file
+ int nHeight : height in block chain
+ int blockVersion : ??? Not sure why version is repeated...
+ uint256 hashPrev
+ uint256 hashMerkleRoot
+ uint32 nTime
+ uint32 nBits
+ uint32 nNonce
+
+CBlock:
+ # Note: 4 bytes: f9 be b4 d9 are written before records in blk000N.dat files
+ # But the nBlockPos pointers in CDiskBlockIndex points to start of serializedSize
+ int serializedSize
+ int version
+ uint256 hashPrev
+ uint256 hashMerkleRoot
+ uint32 nTime
+ uint32 nBits
+ uint32 nNonce
+ vector<CTransaction>
+
+CAddress:
+ int nVersion
+ unsigned int nTime
+ uint64 nServices
+ unsigned char[12] pchReserved
+ unsigned int ip
+ unsigned short port
+
+CTransaction:
+ int nVersion
+ vector<CTxIn> vin
+ vector<CTxOut> vout
+ unsigned int nLockTime
+
+CTxIn:
+ COutPoint prevout
+ CScript scriptSig
+ unsigned int nSequence
+
+CTxOut:
+ int64 nValue
+ CScript scriptPubKey
+
+COutPoint:
+ 36 bytes(FLATDATA): 32-byte hash, 4-byte unsigned int
+
+CScript:
+ vector<unsigned char> containing built-in little scripting-language script
+ (opcodes and arguments to do crypto stuff)
+
+CMerkleTx:
+ ... serialize CTransaction, then:
+ uint256 hashBlock
+ vector<uint256> vMerkleBranch
+ int nIndex
+
+CWalletTx:
+ ... serialized CMerkleTx, then:
+ vector<CMerkleTx> vtxPrev
+ map<string,string> mapValue
+ vector<pair<string,string> > vOrderForm
+ unsigned int fTimeReceivedIsTxTime
+ unsigned int nTimeReceived
+ char fFromMe
+ char fSpent
+
+CInv:
+ int type : 1:tx 2:block
+ uint256 hash
+
+CBlockLocator:
+ int nVersion
+ vector<uint256> # Block hashes, newest back to genesis block (dense to start, but then sparse)
+
+string:
+ 1/3/5/9 bytes giving length:
+ 1 byte if length < 253.
+ otherwise byte value '253'+ushort, '254'+uint, '255'+uint64
+ then length bytes.
+
+vector<type>:
+ 1/3/5/9 bytes giving count (see string, above)
+ followed by that many <types> serialized one-after-another
+
+pair:
+ just first item followed by second item
+
+
+PUBLIC KEYS TO BITCOIN ADDRESSES
+--------------------------------
+
+Public key, in memory (65 bytes):
+
+0x94c7818: 0x04 0x57 0xcc 0xad 0xd7 0x1e 0xb0 0xf3
+0x94c7820: 0xc1 0x9d 0x22 0xb9 0xba 0x0e 0xa1 0xf3
+0x94c7828: 0x44 0x2a 0x6f 0x12 0x31 0x46 0xb5 0xbd
+0x94c7830: 0xff 0x10 0x60 0xbc 0xd1 0x11 0x68 0xe6
+0x94c7838: 0x6a 0x71 0xbe 0xd4 0xda 0x17 0x7c 0x12
+0x94c7840: 0xd7 0x30 0x9a 0xdd 0xfd 0xf5 0x6c 0x31
+0x94c7848: 0xd5 0xc8 0xa2 0x7b 0x8e 0x6a 0x22 0x20
+0x94c7850: 0x38 0x42 0xc6 0xc2 0x4f 0xd5 0x9b 0xd7
+0x94c7858: 0xb7
+Python string:
+public_key = "\x04\x57\xcc\xad\xd7\x1e\xb0\xf3\xc1\x9d\x22\xb9\xba\x0e\xa1\xf3\x44\x2a\x6f\x12\x31\x46\xb5\xbd\xff\x10\x60\xbc\xd1\x11\x68\xe6\x6a\x71\xbe\xd4\xda\x17\x7c\x12\xd7\x30\x9a\xdd\xfd\xf5\x6c\x31\xd5\xc8\xa2\x7b\x8e\x6a\x22\x20\x38\x42\xc6\xc2\x4f\xd5\x9b\xd7\xb7"
+
+SHA256 hash of that is:
+0xb6890938: 0x0d 0x72 0xab 0x02 0xc8 0xab 0x52 0xce
+0xb6890940: 0x7e 0x6b 0x04 0x00 0x95 0x58 0x09 0xf0
+0xb6890948: 0x93 0x48 0x21 0xb6 0x26 0xc3 0x27 0xc7
+0xb6890950: 0x9a 0x07 0x62 0xfd 0xbc 0x5e 0xb8 0xa5
+h1 = SHA256.new(public_key).digest()
+
+RIPEMD160(SHA256(public key)) is:
+0xb68909ac: 0x5c 0xc8 0x7f 0x4a 0x3f 0xdf 0xe3 0xa2
+0xb68909b4: 0x34 0x6b 0x69 0x53 0x26 0x7c 0xa8 0x67
+0xb68909bc: 0x28 0x26 0x30 0xd3
+h2 = RIPEMD160.new(h1).digest()
+
+Put version number '0x00' byte onto front:
+0x9eeb840: 0x00 0x5c 0xc8 0x7f 0x4a 0x3f 0xdf 0xe3
+0x9eeb848: 0xa2 0x34 0x6b 0x69 0x53 0x26 0x7c 0xa8
+0x9eeb850: 0x67 0x28 0x26 0x30 0xd3
+vh2 = "\x00"+h2
+
+Hash (double-SHA256) that:
+0xb68908e8: 0xf9 0xb7 0x8e 0x64 0x6e 0x20 0x27 0xc4
+0xb68908f0: 0xaa 0x62 0x66 0x04 0x2e 0xb6 0xa2 0xe0
+0xb68908f8: 0x41 0x03 0x9d 0xd8 0xe2 0x24 0x24 0xe8
+0xb6890900: 0x50 0xac 0x20 0x29 0xfb 0xcd 0xb4 0x6e
+h3=SHA256.new(SHA256.new(vh2).digest()).digest()
+
+Add first 4 bytes from Hash object onto end as check-bytes:
+0x9fa6628: 0x00 0x5c 0xc8 0x7f 0x4a 0x3f 0xdf 0xe3
+0x9fa6630: 0xa2 0x34 0x6b 0x69 0x53 0x26 0x7c 0xa8
+0x9fa6638: 0x67 0x28 0x26 0x30 0xd3 0xf9 0xb7 0x8e
+0x9fa6640: 0x64
+addr=vh2+h3[0:4]
+
+Result length should be: int(math.floor(len(addr)*8/math.log(58,2)))
+Base58 encode that, front-pad with '1's if less than expected length
+to get: 19TbMSWwHvnxAKy12iNm3KdbGfzfaMFViT
+
+
+WIRE PROTOCOL NOTES
+-------------------
+Default port is 8333
+
+// Message format
+// (4) message start { 0xf9, 0xbe, 0xb4, 0xd9 }
+// (12) command
+// (4) size -- number of bytes of data
+// (4) checksum -- First four bytes of double SHA256 hash of data
+// (x) data
+
+ --> messages might be split by network layer...
+
+Commands are:
+
+"version" :
+ int nVersion
+ uint64 nServices
+ int64 nTime
+ CAddress addrMe
+ CAddress addrFrom # if nVersion > 106
+ uint64 nNonce
+ string strSubVer # if nVersion > 106
+ int nStartingHeight # if nVersion > 209
+
+nNonce is random value (I think), used to detect self-connection.
+
+"verack" : no data. Sent to sync min version (peer, peer)
+
+"addr" :
+ vector<CAddress>
+ (relayed to 10 random nodes so they spread)
+
+"inv" :
+ vector<CInv>
+
+"getdata" : Asks for blocks or tx's (response is "block" or "tx" messages)
+ vector<CInv>
+
+"getblocks" :
+ CBLockLocator
+ uint256 hashStop
+
+"tx" :
+ CTransaction
+
+"block" :
+ CBlock
+
+"getaddr" : no data ("please send me addr messages")
+
+"checkorder"
+ uint256 hashReply
+ CWalletTx order
+
+"submitorder"
+ uint256 hashReply
+ CWalletTx wtxNew
+
+"reply"
+ uint256 hashReply
+
+"ping" : no data (and no reply)
+
+
+TRANSACTION SIGNING NOTES
+-------------------------
+
+So, I want to spend some bitcoin.
+First, I gotta have a Transaction to me-- specifically, a Transaction with a TxOut that contains a scriptPubKey that I can satisfy.
+
+TxOut.scriptPubKey's come in a couple different flavors:
+ DUP HASH160 {hash160(public_key) EQUALVERIFY CHECKSIG
+ --> I have to be able to supply a matching TxIn.scriptSig with: signature and public key
+ (public key) CHECKSIG
+ --> I have to supply a matching TxIn.scriptSig with: signature
+
+TODO: figure out what, exactly, is hashed (and how), and how, exactly, that hash value is signed with the private key.
+
+DIFFICULTY, NBITS, BN_mpi2bn
+----------------------------
+
+Hash targets are stored as "compact bignums;" the production block chain has an initial target of:
+0x1d00ffff ... which means "create a bignum that is 0x1d (29) bytes long and has 0x00ffff as the
+three bytes on the big end." Or: 0xffff0000000000000000000000000000000000000000000000000000
+
+As I write this, the current block->nBits is 0x1c010c5. To compute difficulty:
+ php -r '$nBits = 0x1c010c5a; print( (0xffff << ((0x1d-($nBits>>24))*8)) / ($nBits&0xffffff) );'
+
+
--- /dev/null
+----- dbdump.py -----
+Run dbdump.py --help for usage. Database files are opened read-only, but
+you might want to backup your Bitcoin wallet.dat file just in case.
+
+You must quit Bitcoin before reading the transactions, blocks, or address database files.
+
+Requires the pycrypto library from http://www.dlitz.net/software/pycrypto/
+to translate public keys into human-friendly Bitcoin addresses.
+
+Examples:
+
+Print out wallet keys and transactions:
+ dbdump.py --wallet --wallet-tx
+
+Print out the "genesis block" (the very first block in the proof-of-work block chain):
+ dbdump.py --block=000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
+
+Print out one of the transactions from my wallet:
+ dbdump.py --transaction=c6e1bf883bceef0aa05113e189982055d9ba7212ddfc879798616a0d0828c98c
+ dbdump.py --transaction=c6e1...c98c
+
+Print out all 'received' transactions that aren't yet spent:
+ dbdump.py --wallet-tx-filter='fromMe:False.*spent:False'
+
+Print out all blocks involving transactions to the Bitcoin Faucet:
+ dbdump.py --search-blocks=15VjRaDX9zpbA8LVnbrCAFzrVzN7ixHNsC
+
+There's a special search term to look for non-standard transactions:
+ dbdump.py --search-blocks=NONSTANDARD_CSCRIPTS
+
+----- statistics.py -----
+Scan all the transactions in the block chain and dump out a .csv file that shows transaction volume per month.
+
+----- fixwallet.py -----
+Half-baked utility that reads a wallet.dat and writes out a new wallet.dat.
+
+Only half-baked because to be really useful I'd have to write serialize routines to re-pack data after modifying it...
+
+----- jsonToCSV.py -----
+Read JSON list-of-objects from standard input, writes CSV file to standard output.
+Useful for converting bitcoind's listtransactions output to CSV that can be
+imported into a spreadsheet.
--- /dev/null
+#
+# Code for parsing the addr.dat file
+# NOTE: I think you have to shutdown the Bitcoin client to
+# successfully read addr.dat...
+#
+
+from bsddb.db import *
+import logging
+from operator import itemgetter
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address
+from util import short_hex
+from deserialize import *
+
+def dump_addresses(db_env):
+ db = DB(db_env)
+ try:
+ r = db.open("addr.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open addr.dat/main. Try quitting Bitcoin and running this again.")
+ sys.exit(1)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ for (key, value) in db.items():
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+
+ if type == "addr":
+ d = parse_CAddress(vds)
+ print(deserialize_CAddress(d))
+
+ db.close()
--- /dev/null
+#!/usr/bin/env python
+
+"""encode/decode base58 in the same way that Bitcoin does"""
+
+import math
+
+__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+__b58base = len(__b58chars)
+
+def b58encode(v):
+ """ encode v, which is a string of bytes, to base58.
+ """
+
+ long_value = 0L
+ for (i, c) in enumerate(v[::-1]):
+ long_value += (256**i) * ord(c)
+
+ result = ''
+ while long_value >= __b58base:
+ div, mod = divmod(long_value, __b58base)
+ result = __b58chars[mod] + result
+ long_value = div
+ result = __b58chars[long_value] + result
+
+ # Bitcoin does a little leading-zero-compression:
+ # leading 0-bytes in the input become leading-1s
+ nPad = 0
+ for c in v:
+ if c == '\0': nPad += 1
+ else: break
+
+ return (__b58chars[0]*nPad) + result
+
+def b58decode(v, length):
+ """ decode v into a string of len bytes
+ """
+ long_value = 0L
+ for (i, c) in enumerate(v[::-1]):
+ long_value += __b58chars.find(c) * (__b58base**i)
+
+ result = ''
+ while long_value >= 256:
+ div, mod = divmod(long_value, 256)
+ result = chr(mod) + result
+ long_value = div
+ result = chr(long_value) + result
+
+ nPad = 0
+ for c in v:
+ if c == __b58chars[0]: nPad += 1
+ else: break
+
+ result = chr(0)*nPad + result
+ if length is not None and len(result) != length:
+ return None
+
+ return result
+
+try:
+ # Python Crypto library is at: http://www.dlitz.net/software/pycrypto/
+ # Needed for RIPEMD160 hash function, used to compute
+ # Bitcoin addresses from internal public keys.
+ import Crypto.Hash.SHA256 as SHA256
+ import Crypto.Hash.RIPEMD160 as RIPEMD160
+ have_crypto = True
+except ImportError:
+ have_crypto = False
+
+def hash_160(public_key):
+ if not have_crypto:
+ return ''
+ h1 = SHA256.new(public_key).digest()
+ h2 = RIPEMD160.new(h1).digest()
+ return h2
+
+def public_key_to_bc_address(public_key):
+ if not have_crypto:
+ return ''
+ h160 = hash_160(public_key)
+ return hash_160_to_bc_address(h160)
+
+def hash_160_to_bc_address(h160):
+ if not have_crypto:
+ return ''
+ vh160 = "\x00"+h160 # \x00 is version 0
+ h3=SHA256.new(SHA256.new(vh160).digest()).digest()
+ addr=vh160+h3[0:4]
+ return b58encode(addr)
+
+def bc_address_to_hash_160(addr):
+ bytes = b58decode(addr, 25)
+ return bytes[1:21]
+
+if __name__ == '__main__':
+ x = '005cc87f4a3fdfe3a2346b6953267ca867282630d3f9b78e64'.decode('hex_codec')
+ encoded = b58encode(x)
+ print encoded, '19TbMSWwHvnxAKy12iNm3KdbGfzfaMFViT'
+ print b58decode(encoded, len(x)).encode('hex_codec'), x.encode('hex_codec')
--- /dev/null
+#
+# Code for parsing the blkindex.dat file
+#
+
+from bsddb.db import *
+import logging
+from operator import itemgetter
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address
+from util import short_hex
+from deserialize import *
+
+def dump_blkindex_summary(db_env):
+ db = DB(db_env)
+ try:
+ r = db.open("blkindex.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open blkindex.dat/main. Try quitting any running Bitcoin apps.")
+ sys.exit(1)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ n_tx = 0
+ n_blockindex = 0
+
+ print("blkindex file summary:")
+ for (key, value) in db.items():
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+
+ if type == "tx":
+ n_tx += 1
+ elif type == "blockindex":
+ n_blockindex += 1
+ elif type == "version":
+ version = vds.read_int32()
+ print(" Version: %d"%(version,))
+ elif type == "hashBestChain":
+ hash = vds.read_bytes(32)
+ print(" HashBestChain: %s"%(hash.encode('hex_codec'),))
+ else:
+ logging.warn("blkindex: unknown type '%s'"%(type,))
+ continue
+
+ print(" %d transactions, %d blocks."%(n_tx, n_blockindex))
+ db.close()
--- /dev/null
+#
+# Code for dumping a single block, given its ID (hash)
+#
+
+from bsddb.db import *
+import logging
+import os.path
+import re
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address
+from util import short_hex, long_hex
+from deserialize import *
+
+def _open_blkindex(db_env):
+ db = DB(db_env)
+ try:
+ r = db.open("blkindex.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
+ except DBError:
+ r = True
+ if r is not None:
+ logging.error("Couldn't open blkindex.dat/main. Try quitting any running Bitcoin apps.")
+ sys.exit(1)
+ return db
+
+def _read_CDiskTxPos(stream):
+ n_file = stream.read_uint32()
+ n_block_pos = stream.read_uint32()
+ n_tx_pos = stream.read_uint32()
+ return (n_file, n_block_pos, n_tx_pos)
+
+def _dump_block(datadir, nFile, nBlockPos, hash256, hashNext, do_print=True):
+ blockfile = open(os.path.join(datadir, "blk%04d.dat"%(nFile,)), "rb")
+ ds = BCDataStream()
+ ds.map_file(blockfile, nBlockPos)
+ d = parse_Block(ds)
+ block_string = deserialize_Block(d)
+ ds.close_file()
+ blockfile.close()
+ if do_print:
+ print "BLOCK "+long_hex(hash256[::-1])
+ print "Next block: "+long_hex(hashNext[::-1])
+ print block_string
+ return block_string
+
+def _parse_block_index(vds):
+ d = {}
+ d['version'] = vds.read_int32()
+ d['hashNext'] = vds.read_bytes(32)
+ d['nFile'] = vds.read_uint32()
+ d['nBlockPos'] = vds.read_uint32()
+ d['nHeight'] = vds.read_int32()
+
+ header_start = vds.read_cursor
+ d['b_version'] = vds.read_int32()
+ d['hashPrev'] = vds.read_bytes(32)
+ d['hashMerkle'] = vds.read_bytes(32)
+ d['nTime'] = vds.read_int32()
+ d['nBits'] = vds.read_int32()
+ d['nNonce'] = vds.read_int32()
+ header_end = vds.read_cursor
+ d['__header__'] = vds.input[header_start:header_end]
+ return d
+
+def dump_block(datadir, db_env, block_hash):
+ """ Dump a block, given hexadecimal hash-- either the full hash
+ OR a short_hex version of the it.
+ """
+ db = _open_blkindex(db_env)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ n_blockindex = 0
+
+ key_prefix = "\x0ablockindex"
+ cursor = db.cursor()
+ (key, value) = cursor.set_range(key_prefix)
+
+ while key.startswith(key_prefix):
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+ hash256 = kds.read_bytes(32)
+ hash_hex = long_hex(hash256[::-1])
+ block_data = _parse_block_index(vds)
+
+ if (hash_hex.startswith(block_hash) or short_hex(hash256[::-1]).startswith(block_hash)):
+ print "Block height: "+str(block_data['nHeight'])
+ _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'], hash256, block_data['hashNext'])
+
+ (key, value) = cursor.next()
+
+ db.close()
+
+def read_block(db_cursor, hash):
+ (key,value) = db_cursor.set_range("\x0ablockindex"+hash)
+ vds = BCDataStream()
+ vds.clear(); vds.write(value)
+ block_data = _parse_block_index(vds)
+ block_data['hash256'] = hash
+ return block_data
+
+def scan_blocks(datadir, db_env, callback_fn):
+ """ Scan through blocks, from last through genesis block,
+ calling callback_fn(block_data) for each.
+ callback_fn should return False if scanning should
+ stop, True if it should continue.
+ Returns last block_data scanned.
+ """
+ db = _open_blkindex(db_env)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ # Read the hashBestChain record:
+ cursor = db.cursor()
+ (key, value) = cursor.set_range("\x0dhashBestChain")
+ vds.write(value)
+ hashBestChain = vds.read_bytes(32)
+
+ block_data = read_block(cursor, hashBestChain)
+
+ while callback_fn(block_data):
+ if block_data['nHeight'] == 0:
+ break;
+ block_data = read_block(cursor, block_data['hashPrev'])
+ return block_data
+
+
+def dump_block_n(datadir, db_env, block_number):
+ """ Dump a block given block number (== height, genesis block is 0)
+ """
+ def scan_callback(block_data):
+ return not block_data['nHeight'] == block_number
+
+ block_data = scan_blocks(datadir, db_env, scan_callback)
+
+ print "Block height: "+str(block_data['nHeight'])
+ _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'], block_data['hash256'], block_data['hashNext'])
+
+def search_blocks(datadir, db_env, pattern):
+ """ Dump a block given block number (== height, genesis block is 0)
+ """
+ db = _open_blkindex(db_env)
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ # Read the hashBestChain record:
+ cursor = db.cursor()
+ (key, value) = cursor.set_range("\x0dhashBestChain")
+ vds.write(value)
+ hashBestChain = vds.read_bytes(32)
+ block_data = read_block(cursor, hashBestChain)
+
+ if pattern == "NONSTANDARD_CSCRIPTS": # Hack to look for non-standard transactions
+ search_odd_scripts(datadir, cursor, block_data)
+ return
+
+ while True:
+ block_string = _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'],
+ block_data['hash256'], block_data['hashNext'], False)
+
+ if re.search(pattern, block_string) is not None:
+ print "MATCH: Block height: "+str(block_data['nHeight'])
+ print block_string
+
+ if block_data['nHeight'] == 0:
+ break
+ block_data = read_block(cursor, block_data['hashPrev'])
+
+def search_odd_scripts(datadir, cursor, block_data):
+ """ Look for non-standard transactions """
+ while True:
+ block_string = _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'],
+ block_data['hash256'], block_data['hashNext'], False)
+
+ found_nonstandard = False
+ for m in re.finditer(r'TxIn:(.*?)$', block_string, re.MULTILINE):
+ s = m.group(1)
+ if re.match(r'\s*COIN GENERATED coinbase:\w+$', s): continue
+ if re.match(r'.*sig: \d+:\w+...\w+ \d+:\w+...\w+$', s): continue
+ if re.match(r'.*sig: \d+:\w+...\w+$', s): continue
+ print "Nonstandard TxIn: "+s
+ found_nonstandard = True
+ break
+
+ for m in re.finditer(r'TxOut:(.*?)$', block_string, re.MULTILINE):
+ s = m.group(1)
+ if re.match(r'.*Script: DUP HASH160 \d+:\w+...\w+ EQUALVERIFY CHECKSIG$', s): continue
+ if re.match(r'.*Script: \d+:\w+...\w+ CHECKSIG$', s): continue
+ print "Nonstandard TxOut: "+s
+ found_nonstandard = True
+ break
+
+ if found_nonstandard:
+ print "NONSTANDARD TXN: Block height: "+str(block_data['nHeight'])
+ print block_string
+
+ if block_data['nHeight'] == 0:
+ break
+ block_data = read_block(cursor, block_data['hashPrev'])
+
+def check_block_chain(db_env):
+ """ Make sure hashPrev/hashNext pointers are consistent through block chain """
+ db = _open_blkindex(db_env)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ # Read the hashBestChain record:
+ cursor = db.cursor()
+ (key, value) = cursor.set_range("\x0dhashBestChain")
+ vds.write(value)
+ hashBestChain = vds.read_bytes(32)
+
+ back_blocks = []
+
+ block_data = read_block(cursor, hashBestChain)
+
+ while block_data['nHeight'] > 0:
+ back_blocks.append( (block_data['nHeight'], block_data['hashMerkle'], block_data['hashPrev'], block_data['hashNext']) )
+ block_data = read_block(cursor, block_data['hashPrev'])
+
+ back_blocks.append( (block_data['nHeight'], block_data['hashMerkle'], block_data['hashPrev'], block_data['hashNext']) )
+ genesis_block = block_data
+
+ print("check block chain: genesis block merkle hash is: %s"%(block_data['hashMerkle'][::-1].encode('hex_codec')))
+
+ while block_data['hashNext'] != ('\0'*32):
+ forward = (block_data['nHeight'], block_data['hashMerkle'], block_data['hashPrev'], block_data['hashNext'])
+ back = back_blocks.pop()
+ if forward != back:
+ print("Forward/back block mismatch at height %d!"%(block_data['nHeight'],))
+ print(" Forward: "+str(forward))
+ print(" Back: "+str(back))
+ block_data = read_block(cursor, block_data['hashNext'])
--- /dev/null
+#
+# Code for parsing the blkindex.dat file
+#
+
+from bsddb.db import *
+import logging
+from operator import itemgetter
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address
+from util import short_hex
+from deserialize import *
+
+def _read_CDiskTxPos(stream):
+ n_file = stream.read_uint32()
+ n_block_pos = stream.read_uint32()
+ n_tx_pos = stream.read_uint32()
+ return (n_file, n_block_pos, n_tx_pos)
+
+def dump_blockindex(db_env, owner=None, n_to_dump=1000):
+ db = DB(db_env)
+ r = db.open("blkindex.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
+ if r is not None:
+ logging.error("Couldn't open blkindex.dat/main")
+ sys.exit(1)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ wallet_transactions = []
+
+ for (i, (key, value)) in enumerate(db.items()):
+ if i > n_to_dump:
+ break
+
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+
+ if type == "tx":
+ hash256 = kds.read_bytes(32)
+ version = vds.read_uint32()
+ tx_pos = _read_CDiskTxPos(vds)
+ print("Tx(%s:%d %d %d)"%((short_hex(hash256),)+tx_pos))
+ n_tx_out = vds.read_compact_size()
+ for i in range(0,n_tx_out):
+ tx_out = _read_CDiskTxPos(vds)
+ if tx_out[0] != 0xffffffffL: # UINT_MAX means no TxOuts (unspent)
+ print(" ==> TxOut(%d %d %d)"%tx_out)
+
+ else:
+ logging.warn("blkindex: type %s"%(type,))
+ continue
+
+ db.close()
+
--- /dev/null
+#!/usr/bin/env python
+#
+# Code for dumping the bitcoin Berkeley db files in a human-readable format
+#
+from bsddb.db import *
+import logging
+import sys
+
+from address import dump_addresses
+from wallet import dump_wallet, dump_accounts
+from blkindex import dump_blkindex_summary
+from transaction import dump_transaction
+from block import dump_block, dump_block_n, search_blocks, check_block_chain
+from util import determine_db_dir, create_env
+
+def main():
+ import optparse
+ parser = optparse.OptionParser(usage="%prog [options]")
+ parser.add_option("--datadir", dest="datadir", default=None,
+ help="Look for files here (defaults to bitcoin default)")
+ parser.add_option("--wallet", action="store_true", dest="dump_wallet", default=False,
+ help="Print out contents of the wallet.dat file")
+ parser.add_option("--wallet-tx", action="store_true", dest="dump_wallet_tx", default=False,
+ help="Print transactions in the wallet.dat file")
+ parser.add_option("--wallet-tx-filter", action="store", dest="wallet_tx_filter", default="",
+ help="Only print transactions that match given string/regular expression")
+ parser.add_option("--accounts", action="store_true", dest="dump_accounts", default="",
+ help="Print out account names, one per line")
+ parser.add_option("--blkindex", action="store_true", dest="dump_blkindex", default=False,
+ help="Print out summary of blkindex.dat file")
+ parser.add_option("--check-block-chain", action="store_true", dest="check_chain", default=False,
+ help="Scan back and forward through the block chain, looking for inconsistencies")
+ parser.add_option("--address", action="store_true", dest="dump_addr", default=False,
+ help="Print addresses in the addr.dat file")
+ parser.add_option("--transaction", action="store", dest="dump_transaction", default=None,
+ help="Dump a single transaction, given hex transaction id (or abbreviated id)")
+ parser.add_option("--block", action="store", dest="dump_block", default=None,
+ help="Dump a single block, given its hex hash (or abbreviated hex hash) OR block height")
+ parser.add_option("--search-blocks", action="store", dest="search_blocks", default=None,
+ help="Search the block chain for blocks containing given regex pattern")
+ (options, args) = parser.parse_args()
+
+ if options.datadir is None:
+ db_dir = determine_db_dir()
+ else:
+ db_dir = options.datadir
+
+ try:
+ db_env = create_env(db_dir)
+ except DBNoSuchFileError:
+ logging.error("Couldn't open " + db_dir)
+ sys.exit(1)
+
+ dump_tx = options.dump_wallet_tx
+ if len(options.wallet_tx_filter) > 0:
+ dump_tx = True
+ if options.dump_wallet or dump_tx:
+ dump_wallet(db_env, options.dump_wallet, dump_tx, options.wallet_tx_filter)
+ if options.dump_accounts:
+ dump_accounts(db_env)
+
+ if options.dump_addr:
+ dump_addresses(db_env)
+
+ if options.check_chain:
+ check_block_chain(db_env)
+
+ if options.dump_blkindex:
+ dump_blkindex_summary(db_env)
+
+ if options.dump_transaction is not None:
+ dump_transaction(db_dir, db_env, options.dump_transaction)
+
+ if options.dump_block is not None:
+ if len(options.dump_block) < 7: # Probably an integer...
+ try:
+ dump_block_n(db_dir, db_env, int(options.dump_block))
+ except ValueError:
+ dump_block(db_dir, db_env, options.dump_block)
+ else:
+ dump_block(db_dir, db_env, options.dump_block)
+
+ if options.search_blocks is not None:
+ search_blocks(db_dir, db_env, options.search_blocks)
+
+ db_env.close()
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+#
+#
+#
+
+from BCDataStream import *
+from enumeration import Enumeration
+from base58 import public_key_to_bc_address, hash_160_to_bc_address
+import socket
+import time
+from util import short_hex, long_hex
+
+def parse_CAddress(vds):
+ d = {}
+ d['nVersion'] = vds.read_int32()
+ d['nTime'] = vds.read_uint32()
+ d['nServices'] = vds.read_uint64()
+ d['pchReserved'] = vds.read_bytes(12)
+ d['ip'] = socket.inet_ntoa(vds.read_bytes(4))
+ d['port'] = vds.read_uint16()
+ return d
+
+def deserialize_CAddress(d):
+ return d['ip']+":"+str(d['port'])+" (lastseen: %s)"%(time.ctime(d['nTime']),)
+
+def parse_setting(setting, vds):
+ if setting[0] == "f": # flag (boolean) settings
+ return str(vds.read_boolean())
+ elif setting == "addrIncoming":
+ return "" # bitcoin 0.4 purposely breaks addrIncoming setting in encrypted wallets.
+ elif setting[0:4] == "addr": # CAddress
+ d = parse_CAddress(vds)
+ return deserialize_CAddress(d)
+ elif setting == "nTransactionFee":
+ return vds.read_int64()
+ elif setting == "nLimitProcessors":
+ return vds.read_int32()
+ return 'unknown setting'
+
+def parse_TxIn(vds):
+ d = {}
+ d['prevout_hash'] = vds.read_bytes(32)
+ d['prevout_n'] = vds.read_uint32()
+ d['scriptSig'] = vds.read_bytes(vds.read_compact_size())
+ d['sequence'] = vds.read_uint32()
+ return d
+def deserialize_TxIn(d, transaction_index=None, owner_keys=None):
+ if d['prevout_hash'] == "\x00"*32:
+ result = "TxIn: COIN GENERATED"
+ result += " coinbase:"+d['scriptSig'].encode('hex_codec')
+ elif transaction_index is not None and d['prevout_hash'] in transaction_index:
+ p = transaction_index[d['prevout_hash']]['txOut'][d['prevout_n']]
+ result = "TxIn: value: %f"%(p['value']/1.0e8,)
+ result += " prev("+long_hex(d['prevout_hash'][::-1])+":"+str(d['prevout_n'])+")"
+ else:
+ result = "TxIn: prev("+long_hex(d['prevout_hash'][::-1])+":"+str(d['prevout_n'])+")"
+ pk = extract_public_key(d['scriptSig'])
+ result += " pubkey: "+pk
+ result += " sig: "+decode_script(d['scriptSig'])
+ if d['sequence'] < 0xffffffff: result += " sequence: "+hex(d['sequence'])
+ return result
+
+def parse_TxOut(vds):
+ d = {}
+ d['value'] = vds.read_int64()
+ d['scriptPubKey'] = vds.read_bytes(vds.read_compact_size())
+ return d
+
+def deserialize_TxOut(d, owner_keys=None):
+ result = "TxOut: value: %f"%(d['value']/1.0e8,)
+ pk = extract_public_key(d['scriptPubKey'])
+ result += " pubkey: "+pk
+ result += " Script: "+decode_script(d['scriptPubKey'])
+ if owner_keys is not None:
+ if pk in owner_keys: result += " Own: True"
+ else: result += " Own: False"
+ return result
+
+def parse_Transaction(vds):
+ d = {}
+ d['version'] = vds.read_int32()
+ n_vin = vds.read_compact_size()
+ d['txIn'] = []
+ for i in xrange(n_vin):
+ d['txIn'].append(parse_TxIn(vds))
+ n_vout = vds.read_compact_size()
+ d['txOut'] = []
+ for i in xrange(n_vout):
+ d['txOut'].append(parse_TxOut(vds))
+ d['lockTime'] = vds.read_uint32()
+ return d
+def deserialize_Transaction(d, transaction_index=None, owner_keys=None):
+ result = "%d tx in, %d out\n"%(len(d['txIn']), len(d['txOut']))
+ for txIn in d['txIn']:
+ result += deserialize_TxIn(txIn, transaction_index) + "\n"
+ for txOut in d['txOut']:
+ result += deserialize_TxOut(txOut, owner_keys) + "\n"
+ return result
+
+def parse_MerkleTx(vds):
+ d = parse_Transaction(vds)
+ d['hashBlock'] = vds.read_bytes(32)
+ n_merkleBranch = vds.read_compact_size()
+ d['merkleBranch'] = vds.read_bytes(32*n_merkleBranch)
+ d['nIndex'] = vds.read_int32()
+ return d
+
+def deserialize_MerkleTx(d, transaction_index=None, owner_keys=None):
+ tx = deserialize_Transaction(d, transaction_index, owner_keys)
+ result = "block: "+(d['hashBlock'][::-1]).encode('hex_codec')
+ result += " %d hashes in merkle branch\n"%(len(d['merkleBranch'])/32,)
+ return result+tx
+
+def parse_WalletTx(vds):
+ d = parse_MerkleTx(vds)
+ n_vtxPrev = vds.read_compact_size()
+ d['vtxPrev'] = []
+ for i in xrange(n_vtxPrev):
+ d['vtxPrev'].append(parse_MerkleTx(vds))
+
+ d['mapValue'] = {}
+ n_mapValue = vds.read_compact_size()
+ for i in xrange(n_mapValue):
+ key = vds.read_string()
+ value = vds.read_string()
+ d['mapValue'][key] = value
+ n_orderForm = vds.read_compact_size()
+ d['orderForm'] = []
+ for i in xrange(n_orderForm):
+ first = vds.read_string()
+ second = vds.read_string()
+ d['orderForm'].append( (first, second) )
+ d['fTimeReceivedIsTxTime'] = vds.read_uint32()
+ d['timeReceived'] = vds.read_uint32()
+ d['fromMe'] = vds.read_boolean()
+ d['spent'] = vds.read_boolean()
+
+ return d
+
+def deserialize_WalletTx(d, transaction_index=None, owner_keys=None):
+ result = deserialize_MerkleTx(d, transaction_index, owner_keys)
+ result += "%d vtxPrev txns\n"%(len(d['vtxPrev']),)
+ result += "mapValue:"+str(d['mapValue'])
+ if len(d['orderForm']) > 0:
+ result += "\n"+" orderForm:"+str(d['orderForm'])
+ result += "\n"+"timeReceived:"+time.ctime(d['timeReceived'])
+ result += " fromMe:"+str(d['fromMe'])+" spent:"+str(d['spent'])
+ return result
+
+# The CAuxPow (auxiliary proof of work) structure supports merged mining.
+# A flag in the block version field indicates the structure's presence.
+# As of 8/2011, the Original Bitcoin Client does not use it. CAuxPow
+# originated in Namecoin; see
+# https://github.com/vinced/namecoin/blob/mergedmine/doc/README_merged-mining.md.
+def parse_AuxPow(vds):
+ d = parse_MerkleTx(vds)
+ n_chainMerkleBranch = vds.read_compact_size()
+ d['chainMerkleBranch'] = vds.read_bytes(32*n_chainMerkleBranch)
+ d['chainIndex'] = vds.read_int32()
+ d['parentBlock'] = parse_BlockHeader(vds)
+ return d
+
+def parse_BlockHeader(vds):
+ d = {}
+ header_start = vds.read_cursor
+ d['version'] = vds.read_int32()
+ d['hashPrev'] = vds.read_bytes(32)
+ d['hashMerkleRoot'] = vds.read_bytes(32)
+ d['nTime'] = vds.read_uint32()
+ d['nBits'] = vds.read_uint32()
+ d['nNonce'] = vds.read_uint32()
+ header_end = vds.read_cursor
+ d['__header__'] = vds.input[header_start:header_end]
+ return d
+
+def parse_Block(vds):
+ d = parse_BlockHeader(vds)
+ if d['version'] & (1 << 8):
+ d['auxpow'] = parse_AuxPow(vds)
+ d['transactions'] = []
+ nTransactions = vds.read_compact_size()
+ for i in xrange(nTransactions):
+ d['transactions'].append(parse_Transaction(vds))
+
+ return d
+
+def deserialize_Block(d):
+ result = "Time: "+time.ctime(d['nTime'])+" Nonce: "+str(d['nNonce'])
+ result += "\nnBits: 0x"+hex(d['nBits'])
+ result += "\nhashMerkleRoot: 0x"+d['hashMerkleRoot'][::-1].encode('hex_codec')
+ result += "\nPrevious block: "+d['hashPrev'][::-1].encode('hex_codec')
+ result += "\n%d transactions:\n"%len(d['transactions'])
+ for t in d['transactions']:
+ result += deserialize_Transaction(t)+"\n"
+ result += "\nRaw block header: "+d['__header__'].encode('hex_codec')
+ return result
+
+def parse_BlockLocator(vds):
+ d = { 'hashes' : [] }
+ nHashes = vds.read_compact_size()
+ for i in xrange(nHashes):
+ d['hashes'].append(vds.read_bytes(32))
+ return d
+
+def deserialize_BlockLocator(d):
+ result = "Block Locator top: "+d['hashes'][0][::-1].encode('hex_codec')
+ return result
+
+opcodes = Enumeration("Opcodes", [
+ ("OP_0", 0), ("OP_PUSHDATA1",76), "OP_PUSHDATA2", "OP_PUSHDATA4", "OP_1NEGATE", "OP_RESERVED",
+ "OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6", "OP_7",
+ "OP_8", "OP_9", "OP_10", "OP_11", "OP_12", "OP_13", "OP_14", "OP_15", "OP_16",
+ "OP_NOP", "OP_VER", "OP_IF", "OP_NOTIF", "OP_VERIF", "OP_VERNOTIF", "OP_ELSE", "OP_ENDIF", "OP_VERIFY",
+ "OP_RETURN", "OP_TOALTSTACK", "OP_FROMALTSTACK", "OP_2DROP", "OP_2DUP", "OP_3DUP", "OP_2OVER", "OP_2ROT", "OP_2SWAP",
+ "OP_IFDUP", "OP_DEPTH", "OP_DROP", "OP_DUP", "OP_NIP", "OP_OVER", "OP_PICK", "OP_ROLL", "OP_ROT",
+ "OP_SWAP", "OP_TUCK", "OP_CAT", "OP_SUBSTR", "OP_LEFT", "OP_RIGHT", "OP_SIZE", "OP_INVERT", "OP_AND",
+ "OP_OR", "OP_XOR", "OP_EQUAL", "OP_EQUALVERIFY", "OP_RESERVED1", "OP_RESERVED2", "OP_1ADD", "OP_1SUB", "OP_2MUL",
+ "OP_2DIV", "OP_NEGATE", "OP_ABS", "OP_NOT", "OP_0NOTEQUAL", "OP_ADD", "OP_SUB", "OP_MUL", "OP_DIV",
+ "OP_MOD", "OP_LSHIFT", "OP_RSHIFT", "OP_BOOLAND", "OP_BOOLOR",
+ "OP_NUMEQUAL", "OP_NUMEQUALVERIFY", "OP_NUMNOTEQUAL", "OP_LESSTHAN",
+ "OP_GREATERTHAN", "OP_LESSTHANOREQUAL", "OP_GREATERTHANOREQUAL", "OP_MIN", "OP_MAX",
+ "OP_WITHIN", "OP_RIPEMD160", "OP_SHA1", "OP_SHA256", "OP_HASH160",
+ "OP_HASH256", "OP_CODESEPARATOR", "OP_CHECKSIG", "OP_CHECKSIGVERIFY", "OP_CHECKMULTISIG",
+ "OP_CHECKMULTISIGVERIFY",
+ ("OP_SINGLEBYTE_END", 0xF0),
+ ("OP_DOUBLEBYTE_BEGIN", 0xF000),
+ "OP_PUBKEY", "OP_PUBKEYHASH",
+ ("OP_INVALIDOPCODE", 0xFFFF),
+])
+
+def script_GetOp(bytes):
+ i = 0
+ while i < len(bytes):
+ vch = None
+ opcode = ord(bytes[i])
+ i += 1
+ if opcode >= opcodes.OP_SINGLEBYTE_END:
+ opcode <<= 8
+ opcode |= bytes[i]
+ i += 1
+
+ if opcode <= opcodes.OP_PUSHDATA4:
+ nSize = opcode
+ if opcode == opcodes.OP_PUSHDATA1:
+ nSize = ord(bytes[i])
+ i += 1
+ elif opcode == opcodes.OP_PUSHDATA2:
+ nSize = unpack_from('<H', bytes, i)
+ i += 2
+ elif opcode == opcodes.OP_PUSHDATA4:
+ nSize = unpack_from('<I', bytes, i)
+ i += 4
+ vch = bytes[i:i+nSize]
+ i += nSize
+
+ yield (opcode, vch)
+
+def script_GetOpName(opcode):
+ return (opcodes.whatis(opcode)).replace("OP_", "")
+
+def decode_script(bytes):
+ result = ''
+ for (opcode, vch) in script_GetOp(bytes):
+ if len(result) > 0: result += " "
+ if opcode <= opcodes.OP_PUSHDATA4:
+ result += "%d:"%(opcode,)
+ result += short_hex(vch)
+ else:
+ result += script_GetOpName(opcode)
+ return result
+
+def match_decoded(decoded, to_match):
+ if len(decoded) != len(to_match):
+ return False;
+ for i in range(len(decoded)):
+ if to_match[i] == opcodes.OP_PUSHDATA4 and decoded[i][0] <= opcodes.OP_PUSHDATA4:
+ continue # Opcodes below OP_PUSHDATA4 all just push data onto stack, and are equivalent.
+ if to_match[i] != decoded[i][0]:
+ return False
+ return True
+
+def extract_public_key(bytes):
+ decoded = [ x for x in script_GetOp(bytes) ]
+
+ # non-generated TxIn transactions push a signature
+ # (seventy-something bytes) and then their public key
+ # (65 bytes) onto the stack:
+ match = [ opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4 ]
+ if match_decoded(decoded, match):
+ return public_key_to_bc_address(decoded[1][1])
+
+ # The Genesis Block, self-payments, and pay-by-IP-address payments look like:
+ # 65 BYTES:... CHECKSIG
+ match = [ opcodes.OP_PUSHDATA4, opcodes.OP_CHECKSIG ]
+ if match_decoded(decoded, match):
+ return public_key_to_bc_address(decoded[0][1])
+
+ # Pay-by-Bitcoin-address TxOuts look like:
+ # DUP HASH160 20 BYTES:... EQUALVERIFY CHECKSIG
+ match = [ opcodes.OP_DUP, opcodes.OP_HASH160, opcodes.OP_PUSHDATA4, opcodes.OP_EQUALVERIFY, opcodes.OP_CHECKSIG ]
+ if match_decoded(decoded, match):
+ return hash_160_to_bc_address(decoded[2][1])
+
+ return "(None)"
--- /dev/null
+#
+# enum-like type
+# From the Python Cookbook, downloaded from http://code.activestate.com/recipes/67107/
+#
+import types, string, exceptions
+
+class EnumException(exceptions.Exception):
+ pass
+
+class Enumeration:
+ def __init__(self, name, enumList):
+ self.__doc__ = name
+ lookup = { }
+ reverseLookup = { }
+ i = 0
+ uniqueNames = [ ]
+ uniqueValues = [ ]
+ for x in enumList:
+ if type(x) == types.TupleType:
+ x, i = x
+ if type(x) != types.StringType:
+ raise EnumException, "enum name is not a string: " + x
+ if type(i) != types.IntType:
+ raise EnumException, "enum value is not an integer: " + i
+ if x in uniqueNames:
+ raise EnumException, "enum name is not unique: " + x
+ if i in uniqueValues:
+ raise EnumException, "enum value is not unique for " + x
+ uniqueNames.append(x)
+ uniqueValues.append(i)
+ lookup[x] = i
+ reverseLookup[i] = x
+ i = i + 1
+ self.lookup = lookup
+ self.reverseLookup = reverseLookup
+ def __getattr__(self, attr):
+ if not self.lookup.has_key(attr):
+ raise AttributeError
+ return self.lookup[attr]
+ def whatis(self, value):
+ return self.reverseLookup[value]
--- /dev/null
+#!/usr/bin/env python
+#
+# Recover from a semi-corrupt wallet
+#
+from bsddb.db import *
+import logging
+import sys
+
+from wallet import rewrite_wallet, trim_wallet
+from util import determine_db_dir, create_env
+
+def main():
+ import optparse
+ parser = optparse.OptionParser(usage="%prog [options]")
+ parser.add_option("--datadir", dest="datadir", default=None,
+ help="Look for files here (defaults to bitcoin default)")
+ parser.add_option("--out", dest="outfile", default="walletNEW.dat",
+ help="Name of output file (default: walletNEW.dat)")
+ parser.add_option("--clean", action="store_true", dest="clean", default=False,
+ help="Clean out old, spent change addresses and transactions")
+ parser.add_option("--skipkey", dest="skipkey",
+ help="Skip entries with keys that contain given string")
+ parser.add_option("--tweakspent", dest="tweakspent",
+ help="Tweak transaction to mark unspent")
+ (options, args) = parser.parse_args()
+
+ if options.datadir is None:
+ db_dir = determine_db_dir()
+ else:
+ db_dir = options.datadir
+
+ try:
+ db_env = create_env(db_dir)
+ except DBNoSuchFileError:
+ logging.error("Couldn't open " + db_dir)
+ sys.exit(1)
+
+ if options.clean:
+ trim_wallet(db_env, options.outfile)
+
+ elif options.skipkey:
+ def pre_put_callback(type, data):
+ if options.skipkey in data['__key__']:
+ return False
+ return True
+ rewrite_wallet(db_env, options.outfile, pre_put_callback)
+ elif options.tweakspent:
+ txid = options.tweakspent.decode('hex_codec')[::-1]
+ def tweak_spent_callback(type, data):
+ if txid in data['__key__']:
+ data['__value__'] = data['__value__'][:-1]+'\0'
+ return True
+ rewrite_wallet(db_env, options.outfile, tweak_spent_callback)
+ pass
+ else:
+ rewrite_wallet(db_env, options.outfile)
+
+ db_env.close()
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+#!/usr/bin/env python
+#
+# Reads an array of JSON objects and writes out CSV-format,
+# with key names in first row.
+# Columns will be union of all keys in the objects.
+#
+
+import csv
+import json
+import sys
+
+json_string = sys.stdin.read()
+json_array = json.loads(json_string)
+
+columns = set()
+for item in json_array:
+ columns.update(set(item))
+
+writer = csv.writer(sys.stdout)
+writer.writerow(list(columns))
+for item in json_array:
+ row = []
+ for c in columns:
+ if c in item: row.append(str(item[c]))
+ else: row.append('')
+ writer.writerow(row)
+
--- /dev/null
+#!/usr/bin/env python
+#
+# Read the block database, generate monthly statistics and dump out
+# a CSV file.
+#
+from bsddb.db import *
+from datetime import date
+import logging
+import os
+import sys
+
+from BCDataStream import *
+from block import scan_blocks
+from collections import defaultdict
+from deserialize import parse_Block
+from util import determine_db_dir, create_env
+
+def main():
+ import optparse
+ parser = optparse.OptionParser(usage="%prog [options]")
+ parser.add_option("--datadir", dest="datadir", default=None,
+ help="Look for files here (defaults to bitcoin default)")
+ (options, args) = parser.parse_args()
+
+ if options.datadir is None:
+ db_dir = determine_db_dir()
+ else:
+ db_dir = options.datadir
+
+ try:
+ db_env = create_env(db_dir)
+ except DBNoSuchFileError:
+ logging.error("Couldn't open " + db_dir)
+ sys.exit(1)
+
+ blockfile = open(os.path.join(db_dir, "blk%04d.dat"%(1,)), "rb")
+ block_datastream = BCDataStream()
+ block_datastream.map_file(blockfile, 0)
+
+ n_transactions = defaultdict(int)
+ v_transactions = defaultdict(float)
+ v_transactions_min = defaultdict(float)
+ v_transactions_max = defaultdict(float)
+ def gather_stats(block_data):
+ block_datastream.seek_file(block_data['nBlockPos'])
+ data = parse_Block(block_datastream)
+ block_date = date.fromtimestamp(data['nTime'])
+ key = "%d-%02d"%(block_date.year, block_date.month)
+ for txn in data['transactions'][1:]:
+ values = []
+ for txout in txn['txOut']:
+ n_transactions[key] += 1
+ v_transactions[key] += txout['value']
+ values.append(txout['value'])
+ v_transactions_min[key] += min(values)
+ v_transactions_max[key] += max(values)
+ return True
+
+ scan_blocks(db_dir, db_env, gather_stats)
+
+ db_env.close()
+
+ keys = n_transactions.keys()
+ keys.sort()
+ for k in keys:
+ v = v_transactions[k]/1.0e8
+ v_min = v_transactions_min[k]/1.0e8
+ v_max = v_transactions_max[k]/1.0e8
+ # Columns are:
+ # month n_transactions min max total
+ # ... where min and max add up just the smallest or largest
+ # output in each transaction; the true value of bitcoins
+ # transferred will be somewhere between min and max.
+ # We don't know how many are transfers-to-self, though, and
+ # this will undercount multi-txout-transactions (which is good
+ # right now, because they're mostly used for mining pool
+ # payouts that arguably shouldn't count).
+ print "%s,%d,%.2f,%.2f,%.2f"%(k, n_transactions[k], v_min, v_max, v)
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+#
+# Unit tests for BCDataStream class
+#
+
+import unittest
+
+import BCDataStream
+
+class Tests(unittest.TestCase):
+ def setUp(self):
+ self.ds = BCDataStream.BCDataStream()
+
+ def testString(self):
+ t = {
+ "\x07setting" : "setting",
+ "\xfd\x00\x07setting" : "setting",
+ "\xfe\x00\x00\x00\x07setting" : "setting",
+ }
+ for (input, output) in t.iteritems():
+ self.ds.clear()
+ self.ds.write(input)
+ got = self.ds.read_string()
+ self.assertEqual(output, got)
+
+if __name__ == "__main__":
+ unittest.main()
--- /dev/null
+#
+# Code for dumping a single transaction, given its ID
+#
+
+from bsddb.db import *
+import logging
+import os.path
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address
+from util import short_hex
+from deserialize import *
+
+def _read_CDiskTxPos(stream):
+ n_file = stream.read_uint32()
+ n_block_pos = stream.read_uint32()
+ n_tx_pos = stream.read_uint32()
+ return (n_file, n_block_pos, n_tx_pos)
+
+def _dump_tx(datadir, tx_hash, tx_pos):
+ blockfile = open(os.path.join(datadir, "blk%04d.dat"%(tx_pos[0],)), "rb")
+ ds = BCDataStream()
+ ds.map_file(blockfile, tx_pos[2])
+ d = parse_Transaction(ds)
+ print deserialize_Transaction(d)
+ ds.close_file()
+ blockfile.close()
+
+def dump_transaction(datadir, db_env, tx_id):
+ """ Dump a transaction, given hexadecimal tx_id-- either the full ID
+ OR a short_hex version of the id.
+ """
+ db = DB(db_env)
+ try:
+ r = db.open("blkindex.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open blkindex.dat/main. Try quitting any running Bitcoin apps.")
+ sys.exit(1)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ n_tx = 0
+ n_blockindex = 0
+
+ key_prefix = "\x02tx"+(tx_id[-4:].decode('hex_codec')[::-1])
+ cursor = db.cursor()
+ (key, value) = cursor.set_range(key_prefix)
+
+ while key.startswith(key_prefix):
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+ hash256 = (kds.read_bytes(32))
+ hash_hex = long_hex(hash256[::-1])
+ version = vds.read_uint32()
+ tx_pos = _read_CDiskTxPos(vds)
+ if (hash_hex.startswith(tx_id) or short_hex(hash256[::-1]).startswith(tx_id)):
+ _dump_tx(datadir, hash256, tx_pos)
+
+ (key, value) = cursor.next()
+
+ db.close()
+
--- /dev/null
+#
+# Misc util routines
+#
+
+from bsddb.db import *
+
+def long_hex(bytes):
+ return bytes.encode('hex_codec')
+
+def short_hex(bytes):
+ t = bytes.encode('hex_codec')
+ if len(t) < 11:
+ return t
+ return t[0:4]+"..."+t[-4:]
+
+def determine_db_dir():
+ import os
+ import os.path
+ import platform
+ if platform.system() == "Darwin":
+ return os.path.expanduser("~/Library/Application Support/Bitcoin/")
+ elif platform.system() == "Windows":
+ return os.path.join(os.environ['APPDATA'], "Bitcoin")
+ return os.path.expanduser("~/.bitcoin")
+
+def create_env(db_dir=None):
+ if db_dir is None:
+ db_dir = determine_db_dir()
+ db_env = DBEnv(0)
+ r = db_env.open(db_dir,
+ (DB_CREATE|DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|
+ DB_INIT_TXN|DB_THREAD|DB_RECOVER))
+ return db_env
--- /dev/null
+#
+# Code for parsing the wallet.dat file
+#
+
+from bsddb.db import *
+import logging
+import re
+import sys
+import time
+
+from BCDataStream import *
+from base58 import public_key_to_bc_address, bc_address_to_hash_160, hash_160
+from util import short_hex, long_hex
+from deserialize import *
+
+def open_wallet(db_env, writable=False):
+ db = DB(db_env)
+ flags = DB_THREAD | (DB_CREATE if writable else DB_RDONLY)
+ try:
+ r = db.open("wallet.dat", "main", DB_BTREE, flags)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open wallet.dat/main. Try quitting Bitcoin and running this again.")
+ sys.exit(1)
+
+ return db
+
+def parse_wallet(db, item_callback):
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ for (key, value) in db.items():
+ d = { }
+
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+
+ d["__key__"] = key
+ d["__value__"] = value
+ d["__type__"] = type
+
+ try:
+ if type == "tx":
+ d["tx_id"] = kds.read_bytes(32)
+ d.update(parse_WalletTx(vds))
+ elif type == "name":
+ d['hash'] = kds.read_string()
+ d['name'] = vds.read_string()
+ elif type == "version":
+ d['version'] = vds.read_uint32()
+ elif type == "setting":
+ d['setting'] = kds.read_string()
+ d['value'] = parse_setting(d['setting'], vds)
+ elif type == "key":
+ d['public_key'] = kds.read_bytes(kds.read_compact_size())
+ d['private_key'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "wkey":
+ d['public_key'] = kds.read_bytes(kds.read_compact_size())
+ d['private_key'] = vds.read_bytes(vds.read_compact_size())
+ d['created'] = vds.read_int64()
+ d['expires'] = vds.read_int64()
+ d['comment'] = vds.read_string()
+ elif type == "ckey":
+ d['public_key'] = kds.read_bytes(kds.read_compact_size())
+ d['crypted_key'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "mkey":
+ d['nID'] = kds.read_int32()
+ d['crypted_key'] = vds.read_bytes(vds.read_compact_size())
+ d['salt'] = vds.read_bytes(vds.read_compact_size())
+ d['nDerivationMethod'] = vds.read_int32()
+ d['nDeriveIterations'] = vds.read_int32()
+ d['vchOtherDerivationParameters'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "defaultkey":
+ d['key'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "pool":
+ d['n'] = kds.read_int64()
+ d['nVersion'] = vds.read_int32()
+ d['nTime'] = vds.read_int64()
+ d['public_key'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "acc":
+ d['account'] = kds.read_string()
+ d['nVersion'] = vds.read_int32()
+ d['public_key'] = vds.read_bytes(vds.read_compact_size())
+ elif type == "acentry":
+ d['account'] = kds.read_string()
+ d['n'] = kds.read_uint64()
+ d['nVersion'] = vds.read_int32()
+ d['nCreditDebit'] = vds.read_int64()
+ d['nTime'] = vds.read_int64()
+ d['otherAccount'] = vds.read_string()
+ d['comment'] = vds.read_string()
+ elif type == "bestblock":
+ d['nVersion'] = vds.read_int32()
+ d.update(parse_BlockLocator(vds))
+ else:
+ print "Unknown key type: "+type
+
+ item_callback(type, d)
+
+ except Exception, e:
+ print("ERROR parsing wallet.dat, type %s"%type)
+ print("key data in hex: %s"%key.encode('hex_codec'))
+ print("value data in hex: %s"%value.encode('hex_codec'))
+
+def update_wallet(db, type, data):
+ """Write a single item to the wallet.
+ db must be open with writable=True.
+ type and data are the type code and data dictionary as parse_wallet would
+ give to item_callback.
+ data's __key__, __value__ and __type__ are ignored; only the primary data
+ fields are used.
+ """
+ d = data
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ # Write the type code to the key
+ kds.write_string(type)
+ vds.write("") # Ensure there is something
+
+ try:
+ if type == "tx":
+ raise NotImplementedError("Writing items of type 'tx'")
+ kds.write(d['tx_id'])
+ #d.update(parse_WalletTx(vds))
+ elif type == "name":
+ kds.write(d['hash'])
+ vds.write(d['name'])
+ elif type == "version":
+ vds.write_uint32(d['version'])
+ elif type == "setting":
+ raise NotImplementedError("Writing items of type 'setting'")
+ kds.write_string(d['setting'])
+ #d['value'] = parse_setting(d['setting'], vds)
+ elif type == "key":
+ kds.write_string(d['public_key'])
+ vds.write_string(d['private_key'])
+ elif type == "wkey":
+ kds.write_string(d['public_key'])
+ vds.write_string(d['private_key'])
+ vds.write_int64(d['created'])
+ vds.write_int64(d['expires'])
+ vds.write_string(d['comment'])
+ elif type == "ckey":
+ kds.write_string(d['public_key'])
+ kds.write_string(d['crypted_key'])
+ elif type == "mkey":
+ kds.write_int32(d['nID'])
+ vds.write_string(d['crypted_key'])
+ vds.write_string(d['salt'])
+ vds.write_int32(d['nDeriveIterations'])
+ vds.write_int32(d['nDerivationMethod'])
+ vds.write_string(d['vchOtherDerivationParameters'])
+ elif type == "defaultkey":
+ vds.write_string(d['key'])
+ elif type == "pool":
+ kds.write_int64(d['n'])
+ vds.write_int32(d['nVersion'])
+ vds.write_int64(d['nTime'])
+ vds.write_string(d['public_key'])
+ elif type == "acc":
+ kds.write_string(d['account'])
+ vds.write_int32(d['nVersion'])
+ vds.write_string(d['public_key'])
+ elif type == "acentry":
+ kds.write_string(d['account'])
+ kds.write_uint64(d['n'])
+ vds.write_int32(d['nVersion'])
+ vds.write_int64(d['nCreditDebit'])
+ vds.write_int64(d['nTime'])
+ vds.write_string(d['otherAccount'])
+ vds.write_string(d['comment'])
+ elif type == "bestblock":
+ vds.write_int32(d['nVersion'])
+ vds.write_compact_size(len(d['hashes']))
+ for h in d['hashes']:
+ vds.write(h)
+ else:
+ print "Unknown key type: "+type
+
+ # Write the key/value pair to the database
+ db.put(kds.input, vds.input)
+
+ except Exception, e:
+ print("ERROR writing to wallet.dat, type %s"%type)
+ print("data dictionary: %r"%data)
+
+def dump_wallet(db_env, print_wallet, print_wallet_transactions, transaction_filter):
+ db = open_wallet(db_env)
+
+ wallet_transactions = []
+ transaction_index = { }
+ owner_keys = { }
+
+ def item_callback(type, d):
+ if type == "tx":
+ wallet_transactions.append( d )
+ transaction_index[d['tx_id']] = d
+ elif type == "key":
+ owner_keys[public_key_to_bc_address(d['public_key'])] = d['private_key']
+ elif type == "ckey":
+ owner_keys[public_key_to_bc_address(d['public_key'])] = d['crypted_key']
+
+ if not print_wallet:
+ return
+ if type == "tx":
+ return
+ elif type == "name":
+ print("ADDRESS "+d['hash']+" : "+d['name'])
+ elif type == "version":
+ print("Version: %d"%(d['version'],))
+ elif type == "setting":
+ print(d['setting']+": "+str(d['value']))
+ elif type == "key":
+ print("PubKey "+ short_hex(d['public_key']) + " " + public_key_to_bc_address(d['public_key']) +
+ ": PriKey "+ short_hex(d['private_key']))
+ elif type == "wkey":
+ print("WPubKey 0x"+ short_hex(d['public_key']) + " " + public_key_to_bc_address(d['public_key']) +
+ ": WPriKey 0x"+ short_hex(d['crypted_key']))
+ print(" Created: "+time.ctime(d['created'])+" Expires: "+time.ctime(d['expires'])+" Comment: "+d['comment'])
+ elif type == "ckey":
+ print("PubKey "+ short_hex(d['public_key']) + " " + public_key_to_bc_address(d['public_key']) +
+ ": Encrypted PriKey "+ short_hex(d['crypted_key']))
+ elif type == "mkey":
+ print("Master Key %d"%(d['nID']) + ": 0x"+ short_hex(d['crypted_key']) +
+ ", Salt: 0x"+ short_hex(d['salt']) +
+ ". Passphrase hashed %d times with method %d with other parameters 0x"%(d['nDeriveIterations'], d['nDerivationMethod']) +
+ long_hex(d['vchOtherDerivationParameters']))
+ elif type == "defaultkey":
+ print("Default Key: 0x"+ short_hex(d['key']) + " " + public_key_to_bc_address(d['key']))
+ elif type == "pool":
+ print("Change Pool key %d: %s (Time: %s)"% (d['n'], public_key_to_bc_address(d['public_key']), time.ctime(d['nTime'])))
+ elif type == "acc":
+ print("Account %s (current key: %s)"%(d['account'], public_key_to_bc_address(d['public_key'])))
+ elif type == "acentry":
+ print("Move '%s' %d (other: '%s', time: %s, entry %d) %s"%
+ (d['account'], d['nCreditDebit'], d['otherAccount'], time.ctime(d['nTime']), d['n'], d['comment']))
+ elif type == "bestblock":
+ print deserialize_BlockLocator(d)
+ else:
+ print "Unknown key type: "+type
+
+ parse_wallet(db, item_callback)
+
+ if print_wallet_transactions:
+ keyfunc = lambda i: i['timeReceived']
+ for d in sorted(wallet_transactions, key=keyfunc):
+ tx_value = deserialize_WalletTx(d, transaction_index, owner_keys)
+ if len(transaction_filter) > 0 and re.search(transaction_filter, tx_value) is None: continue
+
+ print("==WalletTransaction== "+long_hex(d['tx_id'][::-1]))
+ print(tx_value)
+
+ db.close()
+
+def dump_accounts(db_env):
+ db = open_wallet(db_env)
+
+ kds = BCDataStream()
+ vds = BCDataStream()
+
+ accounts = set()
+
+ for (key, value) in db.items():
+ kds.clear(); kds.write(key)
+ vds.clear(); vds.write(value)
+
+ type = kds.read_string()
+
+ if type == "acc":
+ accounts.add(kds.read_string())
+ elif type == "name":
+ accounts.add(vds.read_string())
+ elif type == "acentry":
+ accounts.add(kds.read_string())
+ # Note: don't need to add otheraccount, because moves are
+ # always double-entry
+
+ for name in sorted(accounts):
+ print(name)
+
+ db.close()
+
+def rewrite_wallet(db_env, destFileName, pre_put_callback=None):
+ db = open_wallet(db_env)
+
+ db_out = DB(db_env)
+ try:
+ r = db_out.open(destFileName, "main", DB_BTREE, DB_CREATE)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open %s."%destFileName)
+ sys.exit(1)
+
+ def item_callback(type, d):
+ if (pre_put_callback is None or pre_put_callback(type, d)):
+ db_out.put(d["__key__"], d["__value__"])
+
+ parse_wallet(db, item_callback)
+
+ db_out.close()
+ db.close()
+
+def trim_wallet(db_env, destFileName, pre_put_callback=None):
+ """Write out ONLY address book public/private keys
+ THIS WILL NOT WRITE OUT 'change' KEYS-- you should
+ send all of your bitcoins to one of your public addresses
+ before calling this.
+ """
+ db = open_wallet(db_env)
+
+ pubkeys = []
+ def gather_pubkeys(type, d):
+ if type == "name":
+ pubkeys.append(bc_address_to_hash_160(d['hash']))
+
+ parse_wallet(db, gather_pubkeys)
+
+ db_out = DB(db_env)
+ try:
+ r = db_out.open(destFileName, "main", DB_BTREE, DB_CREATE)
+ except DBError:
+ r = True
+
+ if r is not None:
+ logging.error("Couldn't open %s."%destFileName)
+ sys.exit(1)
+
+ def item_callback(type, d):
+ should_write = False
+ if type in [ 'version', 'name', 'acc' ]:
+ should_write = True
+ if type in [ 'key', 'wkey', 'ckey' ] and hash_160(d['public_key']) in pubkeys:
+ should_write = True
+ if pre_put_callback is not None:
+ should_write = pre_put_callback(type, d, pubkeys)
+ if should_write:
+ db_out.put(d["__key__"], d["__value__"])
+
+ parse_wallet(db, item_callback)
+
+ db_out.close()
+ db.close()
git://git.novaco.in / novacoin.git / commitdiff