Python BCDataStream.clear方法代码示例

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
def dump_block(datadir, db_env, block_hash, print_raw_tx=False, print_json=False):
  """ 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)):
      if print_json == False:
          print "Block height: "+str(block_data['nHeight'])
          _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'], hash256, block_data['hashNext'], print_raw_tx=print_raw_tx)
      else:
          _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'], hash256, block_data['hashNext'], print_json=print_json, do_print=False)

    (key, value) = cursor.next()

  db.close()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
def dump_keys(db_env, addressStart, outputFileName):
	db = DB(db_env)
	try:
		r = db.open("wallet.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY)
	except DBError:
		logging.error("Couldn't open addr.dat/main. Try quitting Bitcoin and running this again.")
		return

	cString = cStringIO.StringIO()
	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 == "key":
			publicKey = kds.read_bytes(kds.read_compact_size())
			privateKey = vds.read_bytes(vds.read_compact_size())
			address = public_key_to_bc_address(publicKey)
			if address.startswith(addressStart):
				privateKey58 = b58encode(privateKey)
				cString.write('%s\n' % privateKey58)
				print("\nPubKey hex: "+ long_hex(publicKey) + "\nPubKey base58: "+ b58encode(publicKey) + "\nAddress: " +
					address + "\nPriKey hex: "+ long_hex(privateKey) + "\nPriKey base58: "+ privateKey58 + "\n")

	outputText = cString.getvalue()
	if outputText != '':
		writeFileText(outputFileName, outputText)

	db.close()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
def _read_tx(db, txhash):
  kds = BCDataStream()
  vds = BCDataStream()

  key_prefix = "t"+txhash
  cursor = db.iterator(prefix=key_prefix)
  (key, value) = cursor.next()
  kds.clear(); kds.write(key)
  vds.clear(); vds.write(value)

  kds.read_bytes(1)
  hash256 = (kds.read_bytes(32))
  tx_pos = _read_CDiskTxPos(vds)
  return _dump_tx(datadir, hash256, tx_pos)

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
def _read_block(db, blkhash):
  key_prefix = "b"+(blkhash.decode('hex_codec')[::-1])
  cursor = db.iterator(prefix=key_prefix)
  (key, value) = cursor.next()
  vds = BCDataStream()
  vds.clear(); vds.write(value)
  block_data = _parse_block_index(vds)

  print block_data

  if block_data['nStatus'] & 8 == False:
    raise 'no block data, maybe data is downloaded?'
    return
  
  block = _dump_block(datadir, block_data['nFile'], block_data['nBlockPos'], blkhash)
  block['hash256'] = blkhash
  block['nHeight'] = block_data['nHeight']
  return block

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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()

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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)

    try:
      type = kds.read_string()

      d["__key__"] = key
      d["__value__"] = value
      d["__type__"] = type

    except Exception, e:
      print("ERROR attempting to read data from wallet.dat, type %s"%type)
      continue

    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))
      elif type == "cscript":
        d['scriptHash'] = kds.read_bytes(20)
        d['script'] = vds.read_bytes(vds.read_compact_size())
      else:
        print "Skipping item of type "+type
        continue
      
      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'))

# 需要导入模块: import BCDataStream [as 别名]
# 或者: from BCDataStream import clear [as 别名]
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 == "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()
      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'))