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()
