def get_balance(self, addr):
bc = BlockChain()
balance = 0
utxo = UTXOSet()
utxo.reindex(bc)
utxos = utxo.find_utxo(addr)
print(utxos)
for fout in utxos:
balance += fout.txoutput.value
print('%s balance is %d' % (addr, balance))
return balance
def new_genesis_block(self, transaction):
if 'l' not in self.db:
transactions = [transaction]
genesis_block = Block.new_genesis_block(transactions)
genesis_block.set_header_hash()
self.db.create(genesis_block.block_header.hash,
genesis_block.serialize())
self.set_last_hash(genesis_block.block_header.hash)
utxo = UTXOSet()
utxo.update(genesis_block)
def new_genesis_block(self, transaction):
if 'l' not in self.db:
transactions = [transaction]
genesis_block = Block.new_genesis_block(transactions)
# genesis_block.set_header_hash()
data_list = [str(0), str(""), str(""), str(0), str("")]
data = ''.join(data_list)
genesis_block.block_header.hash = sum256_hex(data)
self.db.create(genesis_block.block_header.hash,
genesis_block.serialize())
self.set_last_hash(genesis_block.block_header.hash)
utxo = UTXOSet()
utxo.update(genesis_block)
def start():
bc = BlockChain()
utxo_set = UTXOSet()
utxo_set.reindex(bc)
tcpserver = TCPServer()
tcpserver.listen()
tcpserver.run()
rpc = RPCServer(export_instance=Cli())
rpc.start(False)
p2p = P2p()
server = PeerServer()
server.run(p2p)
p2p.run()
def start(
): # wait : thread add_block(txs) txs = [] packing function >1MB or no tx verify if tx are valid
couch = couchdb.Server("http://127.0.0.1:5984")
try:
couch.delete('block_chain')
except:
pass
db = DB("http://127.0.0.1:5984")
bc = BlockChain() # only one blockchain called bc
utxo_set = UTXOSet()
utxo_set.reindex(bc)
tcpserver = TCPServer()
tcpserver.listen()
tcpserver.run()
rpc = RPCServer(export_instance=Cli())
rpc.start(False)
p2p = P2p()
server = PeerServer()
server.run(p2p)
p2p.run()
time.sleep(30) # automatically create a genesis block
w1 = Wallet.generate_wallet()
ws = Wallets()
ws[w1.address] = w1
ws.save()
tx = bc.coin_base_tx(w1.address)
bc.new_genesis_block(tx)
fo = open("address.txt", "w")
fo.truncate()
fo.write(w1.address) # save the address of the genesis block
fo.write("\n")
w2 = Wallet.generate_wallet() # create another wallet to send transaction
ws[w2.address] = w2
ws.save()
fo.write(w2.address)
fo.close()
def start(
): # wait : thread add_block(txs) txs = [] packing function >1MB or no tx verify if tx are valid
couch = couchdb.Server("http://127.0.0.1:5984")
try:
couch.delete('block_chain')
except:
pass
env_dist = os.environ
db_url1 = "http://couchdb"
db_url1 += env_dist.get('DB_URL')
db_url1 += ":5984"
db = DB(db_url1)
bc = BlockChain() # only one blockchain called bc
utxo_set = UTXOSet()
utxo_set.reindex(bc)
try:
f = open('address.txt', 'r')
addrs = []
for line in f:
addrs.append(line[:34])
f.close()
tx = bc.coin_base_tx(addrs[0])
bc.new_genesis_block(tx)
except:
pass
tcpserver = TCPServer()
tcpserver.listen()
tcpserver.run()
rpc = RPCServer(export_instance=Cli())
rpc.start(False)
t2 = threading.Thread(target=client2, args=())
t2.start()
p2p = P2p()
server = PeerServer()
server.run(p2p)
p2p.run()
def add_block(self, transactions=[], fee=0):
last_block = None
while not last_block:
last_block = self.get_last_block()
time.sleep(5)
prev_hash = last_block.get_header_hash()
height = last_block.block_header.height + 1
block_header = BlockHeader('', height, prev_hash)
f = open('wallet.dat', 'rb')
wallets = pickle.load(f)
keys = list(wallets.keys())
w = wallets[keys[0]]
coin_base_tx = self.coin_base_tx(w.address, fee)
if transactions:
transactions.insert(0, coin_base_tx)
else:
transactions = [coin_base_tx]
utxo_set = UTXOSet()
txs = utxo_set.clear_transactions(transactions)
block = Block(block_header, txs)
block.mine(self)
blo = None
while not blo:
blo = self.get_last_block()
time.sleep(5)
txs1 = blo._transactions
# if len(transactions) > 1:
# if txs1:
# if len(txs1) > 1:
# if txs1[1].txid == txs[1].txid:
# return
block.set_header_hash()
self.db.create(block.block_header.hash, block.serialize())
last_hash = block.block_header.hash
self.set_last_hash(last_hash)
utxo_set.update(block)
def start(
): # wait : thread add_block(txs) txs = [] packing function >1MB or no tx verify if tx are valid
couch = couchdb.Server("http://127.0.0.1:5984")
try:
couch.delete('block_chain')
except:
pass
db = DB("http://127.0.0.1:5984")
bc = BlockChain() # only one blockchain called bc
utxo_set = UTXOSet()
utxo_set.reindex(bc)
tcpserver = TCPServer()
tcpserver.listen()
tcpserver.run()
rpc = RPCServer(export_instance=Cli())
rpc.start(False)
p2p = P2p()
server = PeerServer()
server.run(p2p)
p2p.run()
time.sleep(40)
fo = open("address.txt", "r")
addrs = []
for line in fo:
addrs.append(line)
fo.close()
fee = random.uniform(0.1, 0.6)
amount = 1
tx = bc.new_transaction(addrs[0], addrs[1], amount, fee) # change
tx_pool = TxPool()
tx_pool.add(tx)
try:
server = PeerServer()
server.broadcast_tx(tx)
except Exception as e:
pass
def start(): # wait : thread add_block(txs) txs = [] packing function >1MB or no tx verify if tx are valid
couch = couchdb.Server("http://127.0.0.1:5984")
try:
couch.delete('block_chain')
except:
pass
db = DB("http://127.0.0.1:5984")
bc = BlockChain() # only one blockchain called bc
utxo_set = UTXOSet()
utxo_set.reindex(bc)
tcpserver = TCPServer()
tcpserver.listen()
tcpserver.run()
rpc = RPCServer(export_instance=Cli())
rpc.start(False)
p2p = P2p()
server = PeerServer()
server.run(p2p)
p2p.run()
def add_block_from_peers(self, block):
last_block = self.get_last_block()
utxo = UTXOSet()
if last_block:
prev_hash = last_block.get_header_hash()
last_height = last_block.block_header.height
if block.block_header.height < last_height:
raise ValueError('block height is error')
# if not block.validate(self): # 7.12
# raise ValueError('block is not valid') # 7.12
if block.block_header.height == last_height and block != last_block:
utxo.roll_back(last_block)
self.roll_back()
if block.block_header.height == last_height + 1 and block.block_header.prev_block_hash == last_block.block_header.hash:
self.db.create(block.block_header.hash, block.serialize())
last_hash = block.block_header.hash
self.set_last_hash(last_hash)
utxo.update(block)
else:
self.db.create(block.block_header.hash, block.serialize())
last_hash = block.block_header.hash
self.set_last_hash(last_hash)
utxo.update(block)
def main():
parser = new_parser()
args = parser.parse_args()
s = ServerProxy("http://localhost:9999")
if hasattr(args, 'height'):
block_data = s.print_chain(args.height)
print(block_data)
if hasattr(args, 'address'):
balance = s.get_balance(args.address)
print("%s balance is %d" % (args.address, balance))
if hasattr(args, 'createwallet'):
address = s.create_wallet()
print('Wallet address is %s' % address)
if hasattr(args, 'start'):
start()
if hasattr(args, 'printwallet'):
wallets = s.print_all_wallet()
print('Wallet are:')
for wallet in wallets:
print("\t%s" % wallet)
if hasattr(args, 'genesis_block'):
address = s.create_genesis_block()
print('Genesis Wallet is: %s' % address)
if hasattr(args, 'send_from') \
and hasattr(args, 'send_to') \
and hasattr(args, 'send_amount'):
s.send(args.send_from, args.send_to, args.send_amount) # change
if hasattr(args, 'start_mining'): # change
print("start mining...") # change
s.start_find() # change
print("after start_find") # 7.10
if hasattr(args, 'print_txpool'): # change
txs = s.print_txpool() # change
print(type(txs[0])) # dict
i = 0
for tx in txs: # change
i += 1
print("transaction: ", tx) # change
print("")
print(i)
if hasattr(args, 'sort_txpool'):
txs6, no = s.sort_txpool()
# for i in range(len(txs6)):
# txs6[i] = Transaction.deserialize(txs6[i])
# print("transaction: ", type(txs6[i]))
utxo_set = UTXOSet()
txs6 = utxo_set.clear_transactions(txs6)
print(txs6)
if hasattr(args, 'alive'):
chain_doc = []
bc1 = BlockChain()
last_blo = bc1.get_last_block()
last_height = last_blo.block_header.height
j = 0
m_total_payoff = -11
u_total_payoff = 11.33
users = {}
for i in range(0, last_height + 1):
j += 1
blo = bc1.get_block_by_height(i)
if blo:
txs = blo._transactions
for tx in txs:
if tx.ip:
u_total_payoff -= tx.amount
m_total_payoff += tx.amount
if tx.ip in users.keys():
users[tx.ip] += (1.33 - tx.amount - 0.05 * j)
else:
users[tx.ip] = (1.33 - tx.amount - 0.05 * j)
print(blo.serialize())
print("")
else:
print("problems in the docs")
break
print(j)
print("m_total_payoff ", m_total_payoff)
print("u_total_payoff ", u_total_payoff)
for key in users:
print("the user ", key, "'s pay off is ", users[key])
def _find_unspent_transactions(self, address):
"""
Find all unspent transactions
"""
uxto_set = UTXOSet()
uxto_set.find_utxo(address)
