def main(address):
pool = bitcoin.threadpool(2)
chain = bitcoin.leveldb_blockchain(pool)
chain.start("database", lambda ec: blockchain_started(ec, chain, address))
raw_input()
pool.stop()
pool.join()
chain.stop()
def main():
pool = bitcoin.threadpool(1)
chain = bitcoin.leveldb_blockchain(pool)
future = bitcoin.Future()
chain.start("database", future)
ec, = future.get()
if ec:
print >> sys.stderr, "Couldn't start blockchain:", str(ec)
return False
print "Blockchain started."
sync_chain = bitcoin.SyncBlockchain(chain)
test_methods(sync_chain)
raw_input()
pool.stop()
pool.join()
chain.stop()
return True
def __init__(self):
self._net_pool = bitcoin.threadpool(1)
self._disk_pool = bitcoin.threadpool(1)
self._mem_pool = bitcoin.threadpool(1)
self._hosts = bitcoin.hosts(self._net_pool)
self._handshake = bitcoin.handshake(self._net_pool)
self._network = bitcoin.network(self._net_pool)
self._protocol = bitcoin.protocol(self._net_pool, self._hosts,
self._handshake, self._network)
self._chain = bitcoin.leveldb_blockchain(self._disk_pool)
self._poller = bitcoin.poller(self._mem_pool, self._chain)
self._txpool = bitcoin.transaction_pool(self._mem_pool, self._chain)
pars = bitcoin.create_session_params(self._handshake, self._protocol,
self._chain, self._poller,
self._txpool)
self._session = bitcoin.session(self._net_pool, pars)
self._tx_subscribe = Subscriber()
def __init__(self):
self._net_pool = threadpool(1)
self._disk_pool = threadpool(1)
self._mem_pool = threadpool(1)
self._hosts = hosts(self._net_pool)
self._handshake = handshake(self._net_pool)
self._network = network(self._net_pool)
self._protocol = protocol(self._net_pool,
self._hosts,
self._handshake,
self._network)
self._chain = leveldb_blockchain(self._disk_pool)
self._poller = poller(self._mem_pool, self._chain)
self._txpool = transaction_pool(self._mem_pool, self._chain)
pars = create_session_params(self._handshake,
self._protocol,
self._chain,
self._poller,
self._txpool)
self._session = session(self._net_pool, pars)
self.report("[fullnode] ok")
def __init__(self):
self._net_pool = bitcoin.threadpool(1)
self._disk_pool = bitcoin.threadpool(1)
self._mem_pool = bitcoin.threadpool(1)
self._hosts = bitcoin.hosts(self._net_pool)
self._handshake = bitcoin.handshake(self._net_pool)
self._network = bitcoin.network(self._net_pool)
self._protocol = bitcoin.protocol(self._net_pool,
self._hosts,
self._handshake,
self._network)
self._chain = bitcoin.leveldb_blockchain(self._disk_pool)
self._poller = bitcoin.poller(self._mem_pool, self._chain)
self._txpool = bitcoin.transaction_pool(self._mem_pool, self._chain)
pars = bitcoin.create_session_params(self._handshake,
self._protocol,
self._chain,
self._poller,
self._txpool)
self._session = bitcoin.session(self._net_pool, pars)
self._tx_subscribe = Subscriber()
sys.exit()
blk_hash = hash_block_header(blk)
print "hash:", blk_hash.encode('hex')
print "version:", blk.version
print "previous_block_hash:", blk.previous_block_hash
print "merkle:", blk.merkle
def depth_fetched(ec, depth):
if ec:
print "Failed to fetch last depth:", ec.message()
sys.exit()
print 'depth: ' + str(depth)
ldb_chain.fetch_block_header(depth, display_block_header)
def blockchain_started(ec):
if ec:
print "Blockchain failed to start:", ec.message()
sys.exit()
print "Blockchain started."
ldb_chain.fetch_last_depth(depth_fetched)
pool = threadpool(1)
ldb_chain = leveldb_blockchain(pool)
ldb_chain.start("database", blockchain_started)
raw_input()
pool.stop()
pool.join()
ldb_chain.stop()
if len(block_header.transactions):
print " transactions", block_header.transactions, dir(block_header.transactions), len(block_header.transactions)
for t in block_header.transactions:
print t
print " done"
def import_finished(error):
print "Import finished", error
chain.fetch_block_header(0, fetch_finished)
chain.fetch_block_header(1000, fetch_finished)
print "Import finished2"
# start up engine
pool = bitcoin.threadpool(1)
print pool
chain = bitcoin.leveldb_blockchain(pool)
chain.start("database", blockchain_start);
print 'chain', chain
# load the first block
first_block = bitcoin.genesis_block()
print first_block
chain._import(first_block, 0, import_finished)
# get some block headers
print "fetch block header"
chain.fetch_block_header(0, fetch_finished)
print "waiting..."
#time.sleep(60)
