def create_wallet(self):
wallet = Wallet()
address = wallet.get_address()
self.wallets[address] = wallet
return address
def test_is_valid_transaction_chain_bad_transaction(blockchain_three_blocks):
bad_transaction = Transaction(Wallet(), 'recipient', 1)
bad_transaction.input['signature'] = Wallet().sign(bad_transaction.output)
blockchain_three_blocks.add_block([bad_transaction.to_json()])
with pytest.raises(Exception):
Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
def test_is_valid_transaction_chain_multiple_rewards(blockchain_three_blocks):
reward_1 = Transaction.reward_transaction(Wallet()).to_json()
reward_2 = Transaction.reward_transaction(Wallet()).to_json()
blockchain_three_blocks.add_block([reward_1, reward_2])
with pytest.raises(Exception, match='one mining reward per block.'):
Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
def test_is_valid_transaction_chain_bad_historic_balance(
blockchain_three_blocks):
wallet = Wallet()
bad_transaction = Transaction(wallet, 'recipient', 1)
bad_transaction.output[wallet.address] = 9000
bad_transaction.input['amount'] = 9001
bad_transaction.input['signature'] = wallet.sign(bad_transaction.output)
blockchain_three_blocks.add_block([bad_transaction.to_json()])
with pytest.raises(Exception, match="has an invalid input amount"):
Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
def test_valid_transaction_with_invalid_outputs():
sender_wallet = Wallet()
transaction = Transaction(sender_wallet, 'recipient', 50)
transaction.output[sender_wallet.address] = 9001
with pytest.raises(Exception, match='Invalid transaction output values.'):
Transaction.is_valid_transaction(transaction)
def test_invalid_reward_transaction_invalid_amount():
miner_wallet = Wallet()
reward_transaction = Transaction.reward_transaction(miner_wallet)
reward_transaction.output[miner_wallet.address] = 9001
with pytest.raises(Exception, match="INVALID MINING REWARD"):
Transaction.is_valid_transaction(reward_transaction)
def main():
transaction = Transaction(Wallet(), 'recipient', 15)
print(f'transaction.__dict__: {transaction.__dict__}')
transaction_json = transaction.to_json()
restored_transaction = Transaction.from_json(transaction_json)
print(f'restored_transaction.__dict__: {restored_transaction.__dict__}')
def test_set_transaction():
"""Test that a transaction is set into transactions pool"""
transaction_pool = TransactionPool()
transaction = Transaction(Wallet(), 'recipient', 1)
transaction_pool.set_transaction(transaction)
assert transaction_pool.transaction_map[transaction.id] == transaction
def test_is_valid_transaction_chain_duplicate_transaction(
blockchain_three_blocks):
transaction = Transaction(Wallet(), 'recipient', 1).to_json()
blockchain_three_blocks.add_block([transaction, transaction])
with pytest.raises(Exception, match='is not unique'):
Blockchain.is_valid_transaction_chain(blockchain_three_blocks.chain)
def test_transaction():
sender_wallet = Wallet()
recipient = 'recipient'
amount = 50
transaction = Transaction(sender_wallet, recipient, amount)
assert transaction.output[recipient] == amount
assert transaction.output[
sender_wallet.address] == sender_wallet.balance - amount
assert 'timestamp' in transaction.input
assert transaction.input['amount'] == sender_wallet.balance
assert transaction.input['address'] == sender_wallet.address
assert transaction.input['public_key'] == sender_wallet.public_key
assert Wallet.verify(transaction.input['public_key'], transaction.output,
transaction.input['signature'])
def test_clear_blockchain_transactions():
transaction_pool = TransactionPool()
transaction1 = Transaction(Wallet(), 'recipient', 1)
transaction2 = Transaction(Wallet(), 'recipient', 2)
transaction_pool.set_transaction(transaction1)
transaction_pool.set_transaction(transaction2)
blockchain = Blockchain()
blockchain.add_block([transaction1.to_json(), transaction2.to_json()])
assert transaction1.id in transaction_pool.transaction_map
assert transaction2.id in transaction_pool.transaction_map
transaction_pool.clear_blockchain_transactions(blockchain)
assert transaction1.id not in transaction_pool.transaction_map
assert transaction2.id not in transaction_pool.transaction_map
def test_calculate_balance():
blockchain = Blockchain()
wallet = Wallet()
assert Wallet.calculate_balance(blockchain,
wallet.address) == STARTING_BALANCE
amount = 50
transaction = Transaction(wallet, 'recipient', amount)
blockchain.add_block([transaction.to_json()])
assert Wallet.calculate_balance(
blockchain, wallet.address) == STARTING_BALANCE - amount
received_amount_1 = 25
received_transaction_1 = Transaction(Wallet(), wallet.address,
received_amount_1)
received_amount_2 = 77
received_transaction_2 = Transaction(Wallet(), wallet.address,
received_amount_2)
blockchain.add_block(
[received_transaction_1.to_json(),
received_transaction_2.to_json()])
assert Wallet.calculate_balance(blockchain, wallet.address) == \
STARTING_BALANCE - amount + received_amount_1 + received_amount_2
def test_transaction_updatE():
sender_wallet = Wallet()
first_recipient = 'first_recipient'
first_amount = 50
transaction = Transaction(sender_wallet, first_recipient, first_amount)
next_recipient = 'next_recipient'
next_amount = 75
transaction.update(sender_wallet, next_recipient, next_amount)
assert transaction.output[next_recipient] == next_amount
assert transaction.output[sender_wallet.address] == \
sender_wallet.balance - first_amount - next_amount
assert Wallet.verify(transaction.input['public_key'], transaction.output,
transaction.input['signature'])
to_first_again_amount = 25
transaction.update(sender_wallet, first_recipient, to_first_again_amount)
assert transaction.output[first_recipient] == \
first_amount + to_first_again_amount
assert transaction.output[sender_wallet.address] == \
sender_wallet.balance - first_amount - next_amount - to_first_again_amount
def is_valid_transaction(transaction):
"""
Validate a transaction.
Raise an exception for invalid transactions.
"""
if transaction.input == MINING_REWARD_INPUT:
if list(transaction.output.values()) != [MINING_REWARD]:
raise Exception('INVALID MINING REWARD')
return
output_total = sum(transaction.output.values())
if transaction.input['amount'] != output_total:
raise Exception('Invalid transaction output values.')
if not Wallet.verify(transaction.input['public_key'],
transaction.output,
transaction.input['signature']):
raise Exception('Invalid signature.')
def is_valid_transaction_chain(chain):
"""
Enforce the rules of a chain composed of blocks of transactions:
- Each transaction must only appear once in the chain.
- There can only be one mining reward per block.
- Each transaction must be valid.
"""
transaction_ids = set()
for i in range(len(chain)):
block = chain[i]
has_mining_reward = False
for transaction_json in block.data:
transaction = Transaction.from_json(transaction_json)
if transaction.id in transaction_ids:
raise Exception(
f'Transaction {transaction.id} is not unique.')
transaction_ids.add(transaction.id)
if transaction.input == MINING_REWARD_INPUT:
if has_mining_reward:
raise Exception('There can only be one mining reward per block. '\
f'Check block with hash: {block.hash}')
has_mining_reward = True
else:
historic_blockchain = Blockchain()
historic_blockchain.chain = chain[0:i]
historic_balance = Wallet.calculate_balance(
historic_blockchain, transaction.input['address'])
if historic_balance != transaction.input['amount']:
raise Exception(f'Transaction {transaction.id} has an invalid '\
'input amount')
Transaction.is_valid_transaction(transaction)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
This Document is Created by At 2018/7/8
"""
from core.wallet.wallet import Wallet
if __name__ == "__main__":
w = Wallet()
# todo need to test
# there is something error in th test,
# sometime the assert is ok, but others not.
# so,maybe something need to do to find the bug.
# Mark .
address = w.get_address()
valid = w.validate_addr(address)
print(address)
assert valid is True
import os
import random
import requests
from flask import Flask, jsonify, request
from flask_cors import CORS
from core.blockchain.blockchain import Blockchain
from core.pubsub import PubSub
from core.wallet.wallet import Wallet
from core.wallet.transaction import Transaction
from core.wallet.transaction_pool import TransactionPool
app = Flask(__name__)
CORS(app, resources={r'/*': {'origins': 'http://*****:*****@app.route('/')
def default():
return 'Welcome to the blockchain application.'
@app.route('/blockchain')
def route_blockchain():
return jsonify(blockchain.to_json())
@app.route('/blockchain/range')
def test_verify_valid_signautre():
data = {'foo': 'test-data'}
wallet = Wallet()
signature = wallet.sign(data)
assert Wallet.verify(wallet.public_key, data, signature)
def test_invalid_reward_transaction_extra_recipient():
reward_transaction = Transaction.reward_transaction(Wallet())
reward_transaction.output['extra_recipient'] = 60
with pytest.raises(Exception, match="INVALID MINING REWARD"):
Transaction.is_valid_transaction(reward_transaction)
def test_reward_transaction():
miner_wallet = Wallet()
transaction = Transaction.reward_transaction(miner_wallet)
assert transaction.input == MINING_REWARD_INPUT
assert transaction.output[miner_wallet.address] == MINING_REWARD
def test_valid_reward_transaction():
reward_transaction = Transaction.reward_transaction(Wallet())
Transaction.is_valid_transaction(reward_transaction)
def test_valid_transaction_with_invalid_signature():
transaction = Transaction(Wallet(), 'recipient', 50)
transaction.input['signature'] = Wallet().sign(transaction.output)
with pytest.raises(Exception, match='Invalid signature.'):
Transaction.is_valid_transaction(transaction)
def blockchain_three_blocks():
blockchain = Blockchain()
for i in range(3):
blockchain.add_block([Transaction(Wallet(), 'recipient', i).to_json()])
return blockchain
def test_transaction_exceeds_balance():
with pytest.raises(Exception, match='Amount exceeds balance'):
Transaction(Wallet(), 'recipient', 9001)
def test_transaction_update_exceeds_balance():
sender_wallet = Wallet()
transaction = Transaction(sender_wallet, 'recipient', 50)
with pytest.raises(Exception, match='Amount exceeds balance.'):
transaction.update(sender_wallet, 'new_recipient', 9000)
def get_address(n):
wallet = Wallet()
return [wallet.get_address() for i in range(n)]
def post_wallet_transact(recipient, amount):
return requests.post(f'{BASE_URL}/wallet/transact',
json={
'recipient': recipient,
'amount': amount
}).json()
def get_wallet_info():
return requests.get(f'{BASE_URL}/wallet/info').json()
start_blockchain = get_blockchain()
print(f'start_blockchain: {start_blockchain}')
recipient = Wallet().address
post_wallet_transact_for_first_time = post_wallet_transact(recipient, 45)
print(
f'\npost_wallet_transact_for_first_time: {post_wallet_transact_for_first_time}'
)
time.sleep(1)
post_wallet_transact_for_second_time = post_wallet_transact(recipient, 90)
print(
f'\npost_wallet_transact_for_second_time: {post_wallet_transact_for_second_time}'
)
time.sleep(1)
mined_block = get_blockchain_mine()
print(f'\nmined_block: {mined_block}')
def test_valid_transaction():
Transaction.is_valid_transaction(Transaction(Wallet(), 'recipient', 15))
