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__"]: import pdb pdb.set_trace() 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()
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( "--regex", dest="lookfor", default="/P2SH/", help="Look for string/regular expression (default: %default)" ) parser.add_option( "--n", dest="howmany", default=999999, type="int", help="Look back this many blocks (default: all)" ) parser.add_option( "--start", dest="start", default=0, type="int", help="Skip this many blocks to start (default: 0)" ) parser.add_option("--verbose", dest="verbose", default=False, action="store_true", help="Print blocks that match") (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 = CachedBlockFile(db_dir) results = defaultdict(int) def count_matches(block_data): block_datastream = blockfile.get_stream(block_data["nFile"]) block_datastream.seek_file(block_data["nBlockPos"]) data = parse_Block(block_datastream) coinbase = data["transactions"][0] scriptSig = coinbase["txIn"][0]["scriptSig"] if results["skipped"] < options.start: results["skipped"] += 1 else: results["checked"] += 1 if re.search(options.lookfor, scriptSig) is not None: results["matched"] += 1 if options.verbose: print("Block %d : %s" % (block_data["nHeight"], scriptSig.encode("string_escape"))) results["searched"] += 1 return results["searched"] < options.howmany scan_blocks(db_dir, db_env, count_matches) db_env.close() percent = (100.0 * results["matched"]) / results["checked"] print("Found %d matches in %d blocks (%.1f percent)" % (results["matched"], results["checked"], percent))
def import_key(keyLine, db_dir, input_mode="b58", dryrun=False,verbose=False): if len(keyLine.strip()) == 0: return if input_mode == "b58": priv_bin = privkey_b58_bin(keyLine) elif input_mode == "b64": priv_bin = privkey_b64_bin(keyLine) elif input_mode == "bin": if len(keyLine) not in (32, 279): raise ValueError("Expected a key of 32 or 279 bytes") priv_bin = keyLine if len(priv_bin) == 32: # Get the full DER key priv_bin = priv_to_der(priv_bin) # The public key of a DER-encoded private key is just the last 65 bytes pub_bin = priv_bin[-65:] # Print out the key and address if verbose: print "Private key: %s" % util.long_hex(priv_bin) print "Public key: %s" % util.long_hex(pub_bin) else: print "Private key: %s" % util.short_hex(priv_bin) print "Public key: %s" % util.short_hex(pub_bin) addr = base58.public_key_to_bc_address(pub_bin) if addr == '': # This can happen if pycrypto is not installed, or if the RIPEMD160 # hash is not available (it has been removed in the Debian/Ubuntu # version) print "Warning: Cannot calculate address; check pycrypto library" else: print "Address: %s" % addr # Data for wallet.update_wallet data = { 'private_key': priv_bin, 'public_key': pub_bin, } try: db_env = util.create_env(db_dir) except bsddb.db.DBNoSuchFileError: logging.error("Couldn't open " + db_dir) sys.exit(1) if not dryrun: db = wallet.open_wallet(db_env, writable=True) wallet.update_wallet(db, 'key', data) db.close()
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 = {} v_transactions = {} 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:]: for txout in txn['txOut']: if key in n_transactions: n_transactions[key] += 1 v_transactions[key] += txout['value'] else: n_transactions[key] = 1 v_transactions[key] = txout['value'] 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 print "%s,%d,%.2f" % (k, n_transactions[k], v)
def import_key(keyLine, db_dir, input_mode="b58", dryrun=False, verbose=False): if len(keyLine.strip()) == 0: return if input_mode == "b58": priv_bin = privkey_b58_bin(keyLine) elif input_mode == "b64": priv_bin = privkey_b64_bin(keyLine) elif input_mode == "bin": if len(keyLine) not in (32, 279): raise ValueError("Expected a key of 32 or 279 bytes") priv_bin = keyLine if len(priv_bin) == 32: # Get the full DER key priv_bin = priv_to_der(priv_bin) # The public key of a DER-encoded private key is just the last 65 bytes pub_bin = priv_bin[-65:] # Print out the key and address if verbose: print "Private key: %s" % util.long_hex(priv_bin) print "Public key: %s" % util.long_hex(pub_bin) else: print "Private key: %s" % util.short_hex(priv_bin) print "Public key: %s" % util.short_hex(pub_bin) addr = base58.public_key_to_bc_address(pub_bin) if addr == '': # This can happen if pycrypto is not installed, or if the RIPEMD160 # hash is not available (it has been removed in the Debian/Ubuntu # version) print "Warning: Cannot calculate address; check pycrypto library" else: print "Address: %s" % addr # Data for wallet.update_wallet data = { 'private_key': priv_bin, 'public_key': pub_bin, } try: db_env = util.create_env(db_dir) except bsddb.db.DBNoSuchFileError: logging.error("Couldn't open " + db_dir) sys.exit(1) if not dryrun: db = wallet.open_wallet(db_env, writable=True) wallet.update_wallet(db, 'key', data) db.close()
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) def gather(block_data): block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) height = block_data['nHeight'] coinbase = data['transactions'][0] scriptSig = coinbase['txIn'][0]['scriptSig'] if len(scriptSig) < 4: return True (n, ) = struct.unpack_from('<I', scriptSig[0:4]) if n < 6 * 24 * 365.25 * 100: # 200 years of blocks: print("%d: %d (%s) version: %d/%d" % (height, n, approx_date(n), block_data['b_version'], coinbase['version'])) if ord(scriptSig[0]) == 0x03: (n, ) = struct.unpack_from('<I', scriptSig[1:4] + '\0') if n < 6 * 24 * 365.25 * 100: # 200 years of blocks: print("%d: PUSH %d (%s) version: %d/%d" % (height, n, approx_date(n), block_data['b_version'], coinbase['version'])) return True scan_blocks(db_dir, db_env, gather) db_env.close()
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 = { } v_transactions = { } 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:]: for txout in txn['txOut']: if key in n_transactions: n_transactions[key] += 1 v_transactions[key] += txout['value'] else: n_transactions[key] = 1 v_transactions[key] = txout['value'] 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 print "%s,%d,%.2f"%(k, n_transactions[k], v)
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("--regex", dest="lookfor", default="OP_EVAL", help="Look for string/regular expression") parser.add_option("--n", dest="howmany", default=999999, type="int", help="Look back this many blocks (default: all)") parser.add_option("--verbose", dest="verbose", default=False, action="store_true", help="Print blocks that match") (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) results = defaultdict(int) def count_matches(block_data): block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) coinbase = data['transactions'][0] scriptSig = coinbase['txIn'][0]['scriptSig'] if re.search(options.lookfor, scriptSig) is not None: results['matched'] += 1 if options.verbose: print("Block %d : %s"%(block_data['nHeight'], scriptSig.encode('string_escape')) ) results['searched'] += 1 return results['searched'] < options.howmany scan_blocks(db_dir, db_env, count_matches) db_env.close() print("Found %d matches in %d blocks\n"%(results['matched'], results['searched']))
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("--regex", dest="lookfor", default="OP_EVAL", help="Look for string/regular expression") parser.add_option("--n", dest="howmany", default=-1, type="int", help="Look back this many blocks (default: all)") parser.add_option("--verbose", dest="verbose", default=False, action="store_true", help="Print blocks that match") (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) results = defaultdict(int) def count_matches(block_data): block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) coinbase = data['transactions'][0] scriptSig = coinbase['txIn'][0]['scriptSig'] if re.search(options.lookfor, scriptSig) is not None: results['matched'] += 1 if options.verbose: print("Block %d : %s"%(block_data['nHeight'], scriptSig.encode('string_escape')) ) results['searched'] += 1 return results['searched'] < options.howmany scan_blocks(db_dir, db_env, count_matches) db_env.close() print("Found %d matches in %d blocks\n"%(results['matched'], results['searched']))
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) def gather(block_data): block_datastream.seek_file(block_data["nBlockPos"]) data = parse_Block(block_datastream) height = block_data["nHeight"] coinbase = data["transactions"][0] scriptSig = coinbase["txIn"][0]["scriptSig"] if len(scriptSig) < 4: return True (n,) = struct.unpack_from("<I", scriptSig[0:4]) if n < 6 * 24 * 365.25 * 100: # 200 years of blocks: print("%d: %d (%s)" % (height, n, approx_date(n))) if ord(scriptSig[0]) == 0x03: (n,) = struct.unpack_from("<I", scriptSig[1:4] + "\0") if n < 6 * 24 * 365.25 * 100: # 200 years of blocks: print("%d: PUSH %d (%s)" % (height, n, approx_date(n))) return True scan_blocks(db_dir, db_env, gather) db_env.close()
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 = CachedBlockFile(db_dir) def gather(block_data): block_datastream = blockfile.get_stream(block_data['nFile']) block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) height = block_data['nHeight'] coinbase = data['transactions'][0] scriptSig = coinbase['txIn'][0]['scriptSig'] if len(scriptSig) < 4: return True (n,) = struct.unpack_from('<I', scriptSig[0:4]) if n < 6*24*365.25*100: # 200 years of blocks: print("%d: %d (%s) version: %d/%d"%(height, n, approx_date(n), block_data['b_version'],coinbase['version'])) if ord(scriptSig[0]) == 0x03: (n,) = struct.unpack_from('<I', scriptSig[1:4]+'\0') if n < 6*24*365.25*100: # 200 years of blocks: print("%d: PUSH %d (%s) version: %d/%d"%(height, n, approx_date(n), block_data['b_version'],coinbase['version'])) return True scan_blocks(db_dir, db_env, gather) db_env.close()
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("--address", action="store", dest="addressStart", default="", help="Print keys in the wallet.dat file") parser.add_option("--out", action="store", dest="outputFileName", default="key.txt", help="Save keys in wallet.dat to output file name") (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_keys(db_env, options.addressStart, options.outputFileName) db_env.close()
https://bitcointalk.org/index.php?topic=98986.msg1109747#msg1109747 Dependencies: BitcoinTools: https://github.com/gavinandresen/bitcointools """ from bsddb3.db import * # imports DB* from block import scan_blocks from util import create_env import numpy as np from bitarray import bitarray from binascii import hexlify import pylab db_dir = "/home/amiller/.bitcoin/testdb" db_env = create_env(db_dir) def hash_value(h): # A 'smoother' version of the number of leading zero bits return 256 - np.log2(float(h)) def hash_value2(h): # Count the number of leading zeros if h == 0: return 256 if h > (1 << 256) - 1: return 0 c = 0 while not (h & (1 << 255)): h <<= 1 c += 1
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( "--regex", dest="lookfor", default="/P2SH/", help="Look for string/regular expression (default: %default)") parser.add_option("--n", dest="howmany", default=999999, type="int", help="Look back this many blocks (default: all)") parser.add_option("--start", dest="start", default=0, type="int", help="Skip this many blocks to start (default: 0)") parser.add_option("--verbose", dest="verbose", default=False, action="store_true", help="Print blocks that match") (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 = CachedBlockFile(db_dir) results = defaultdict(int) def count_matches(block_data): block_datastream = blockfile.get_stream(block_data['nFile']) block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) coinbase = data['transactions'][0] scriptSig = coinbase['txIn'][0]['scriptSig'] if results['skipped'] < options.start: results['skipped'] += 1 else: results['checked'] += 1 if re.search(options.lookfor, scriptSig) is not None: results['matched'] += 1 if options.verbose: print("Block %d : %s" % (block_data['nHeight'], scriptSig.encode('string_escape'))) results['searched'] += 1 return results['searched'] < options.howmany scan_blocks(db_dir, db_env, count_matches) db_env.close() percent = (100.0 * results['matched']) / results['checked'] print("Found %d matches in %d blocks (%.1f percent)" % (results['matched'], results['checked'], percent))
https://bitcointalk.org/index.php?topic=98986.msg1109747#msg1109747 Dependencies: BitcoinTools: https://github.com/gavinandresen/bitcointools """ from bsddb3.db import * # imports DB* from block import scan_blocks from util import create_env import numpy as np from bitarray import bitarray from binascii import hexlify import pylab db_dir = "/home/amiller/.bitcoin/testdb" db_env = create_env(db_dir) def hash_value(h): # A 'smoother' version of the number of leading zero bits return 256 - np.log2(float(h)) def hash_value2(h): # Count the number of leading zeros if h == 0: return 256 if h > (1<<256)-1: return 0 c = 0 while not (h & (1<<255)): h <<= 1 c += 1 return c
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()
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()
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("--week", dest="week", default=False, action="store_true", help="Dump day-by-day for the last week's worth of blocks") (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 def gather_stats_week(block_data, lastDate): block_datastream.seek_file(block_data['nBlockPos']) data = parse_Block(block_datastream) block_date = date.fromtimestamp(data['nTime']) if block_date < lastDate: return False key = "%d-%02d-%02d"%(block_date.year, block_date.month, block_date.day) 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 if options.week: lastDate = date.fromordinal(date.today().toordinal()-7) scan_blocks(db_dir, db_env, lambda x: gather_stats_week(x, lastDate) ) else: scan_blocks(db_dir, db_env, gather_stats) db_env.close() print "date,nTransactions,minBTC,maxBTC,totalBTC" 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)
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") parser.add_option("--noaccounts", action="store_true", dest="noaccounts", default=False, help="Drops all accounts from the old wallet") parser.add_option("--nosettings", action="store_true", dest="nosettings", default=False, help="Drops all settings from the old wallet") parser.add_option("--notxes", action="store_true", dest="notxes", default=False, help="Drops transactions from the old wallet, open Bitcoin with -rescan after this") parser.add_option("--noaddresses", action="store_true", dest="nopubkeys", default=False, help="Drops addresses from the old wallet, this will clear your address book leaving only one address\ WARNING: Make sure to refill your keypool after using this (by simply unlocking the wallet)") (options, args) = parser.parse_args() if options.datadir is None: db_dir = determine_db_dir() else: db_dir = options.datadir skip_types = [] if options.nosettings: skip_types.append("version") skip_types.append("setting") skip_types.append("defaultkey") if options.noaccounts: skip_types.append("acc") skip_types.append("acentry") if options.notxes: skip_types.append("tx") skip_types.append("bestblock") if options.nopubkeys: skip_types.append("name") skip_types.append("pool") 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 elif len(skip_types) > 0: def pre_put_callback(type, data): if skip_types.count(type) > 0: return False return True rewrite_wallet(db_env, options.outfile, pre_put_callback) else: rewrite_wallet(db_env, options.outfile) db_env.close()
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") parser.add_option("--print-raw-tx", action="store_true", dest="print_raw_tx", default=False, help="When dumping a block, print raw, hexadecimal transaction data for every transaction, in the same format that getmemorypool uses") parser.add_option("--print-json", action="store_true", dest="print_json", default=False, help="When dumping a block, output it in JSON format (like output of RPC commands)") (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), options.print_raw_tx, options.print_json) except ValueError: dump_block(db_dir, db_env, options.dump_block, options.print_raw_tx, options.print_json) else: dump_block(db_dir, db_env, options.dump_block, options.print_raw_tx, options.print_json) if options.search_blocks is not None: search_blocks(db_dir, db_env, options.search_blocks) db_env.close()
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") parser.add_option("--noaccounts", action="store_true", dest="noaccounts", default=False, help="Drops all accounts from the old wallet") parser.add_option("--nosettings", action="store_true", dest="nosettings", default=False, help="Drops all settings from the old wallet") parser.add_option( "--notxes", action="store_true", dest="notxes", default=False, help= "Drops transactions from the old wallet, open Bitcoin with -rescan after this" ) parser.add_option( "--noaddresses", action="store_true", dest="nopubkeys", default=False, help= "Drops addresses from the old wallet, this will clear your address book leaving only one address\ WARNING: Make sure to refill your keypool after using this (by simply unlocking the wallet)" ) (options, args) = parser.parse_args() if options.datadir is None: db_dir = determine_db_dir() else: db_dir = options.datadir skip_types = [] if options.nosettings: skip_types.append("version") skip_types.append("setting") skip_types.append("defaultkey") if options.noaccounts: skip_types.append("acc") skip_types.append("acentry") if options.notxes: skip_types.append("tx") skip_types.append("bestblock") if options.nopubkeys: skip_types.append("name") skip_types.append("pool") 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 elif len(skip_types) > 0: def pre_put_callback(type, data): if skip_types.count(type) > 0: return False return True rewrite_wallet(db_env, options.outfile, pre_put_callback) else: rewrite_wallet(db_env, options.outfile) db_env.close()