def testCalculateBalance():
blockchain = Blockchain()
wallet = Wallet()
assert Wallet.calculateBalance(blockchain,
wallet.address) == STARTING_BALANCE
amount = 50
transaction = Trasaction(wallet, 'recipient', amount)
blockchain.addBlock(transaction.to_json())
assert Wallet.calculateBalance(blockchain,
wallet.address) == STARTING_BALANCE - amount
recoveryAmount1 = 25
recoveryTransaction1 = Trasaction(Wallet(), wallet.address,
recoveryAmount1)
recoveryAmount2 = 43
recoveryTransaction2 = Trasaction(Wallet(), wallet.address,
recoveryAmount2)
blockchain.addBlock(
[recoveryTransaction1.to_json(),
recoveryTransaction2.to_json()])
assert Wallet.calculateBalance(blockchain, wallet.address) == \
STARTING_BALANCE - amount + recoveryAmount1 + recoveryAmount2
def testIsValidTransactionChainBadTransaction(Blockchain3Blocks):
badTransaction = Trasaction(Wallet(), 'recipient', 1)
badTransaction.input['signature'] = Wallet().sign(badTransaction.output)
Blockchain3Blocks.addBlock([badTransaction.to_json()])
with pytest.raises(Exception):
Blockchain.isValidTransactionChain(Blockchain3Blocks)
def testIsValidTransactionChainMultiRewards(Blockchain3Blocks):
rewardOne = Trasaction.rewardTransaction(Wallet()).to_json()
rewardTwo = Trasaction.rewardTransaction(Wallet()).to_json()
Blockchain3Blocks.addBlock([rewardOne, rewardTwo])
with pytest.raises(Exception, match='one mining reward per block'):
Blockchain.isValidTransactionChain(Blockchain3Blocks.chain)
def testTransactionUpdate():
senderWallet = Wallet()
firstRecipiemt = 'firstRecipient'
firstAmount = 50
transaction = Trasaction(senderWallet, firstRecipiemt, firstAmount)
nextRecipient = 'nextRecipient'
nextAmount = 75
transaction.update(senderWallet, nextRecipient, nextAmount)
assert transaction.output[nextRecipient] == nextAmount
assert transaction.output[senderWallet.address] == \
senderWallet.balance - firstAmount - nextAmount
assert Wallet.verify(transaction.input['public_key'], transaction.output,
transaction.input['signature'])
toFirstAgainAmount = 25
transaction.update(senderWallet, firstRecipiemt, toFirstAgainAmount)
assert transaction.output[firstRecipiemt] == \
firstAmount + toFirstAgainAmount
assert transaction.output[senderWallet.address] == \
senderWallet.balance - firstAmount - nextAmount - toFirstAgainAmount
assert Wallet.verify(transaction.input['public_key'], transaction.output,
transaction.input['signature'])
def testInvalidRewardTransactionInvalidAmount():
minerWallet = Wallet()
rewardTransaction = Trasaction.rewardTransaction(minerWallet)
rewardTransaction.output[minerWallet.address] = 9001
with pytest.raises(Exception, match='Invalid mining reward'):
Trasaction.isValidTransaction(rewardTransaction)
def main():
transaction = Trasaction(Wallet(), 'recipient', 15)
print(f'transaction.__dict__: {transaction.__dict__}')
transactionJson = transaction.to_json()
restoreTransaction = Trasaction.from_json(transactionJson)
print(f'restoreTransaction.__dict__:{restoreTransaction.__dict__}')
def testisValidTransactionChainDuplicate(Blockchain3Blocks):
transaction = Trasaction(Wallet(), 'recipient', 1).to_json()
Blockchain3Blocks.addBlock([transaction, transaction])
with pytest.raises(Exception, match='is not unique'):
Blockchain.isValidTransactionChain(Blockchain3Blocks.chain)
def testClear():
transactionPool = TransactionPool()
transaction1 = Trasaction(Wallet(), 'recipient', 1)
transaction2 = Trasaction(Wallet(), 'recipient', 2)
transactionPool.setTransaction(transaction1)
transactionPool.setTransaction(transaction2)
blockchain = Blockchain()
blockchain.addBlock([transaction1.to_json(), transaction2.to_json()])
assert transaction1.id in transactionPool.transcationMap
assert transaction2.id in transactionPool.transcationMap
transactionPool.clearTransaction(blockchain)
assert not transaction1.id in transactionPool.transcationMap
assert not transaction2.id in transactionPool.transcationMap
def testIsValidTransactionChainBadHistoricBalance(Blockchain3Blocks):
wallet = Wallet()
badTransaction = Trasaction(wallet, 'recipient', 1)
badTransaction.output[wallet.address] = 9000
badTransaction.input['amount'] = 9001
badTransaction.input['signature'] = wallet.sign(badTransaction.output)
Blockchain3Blocks.addBlock([badTransaction.to_json()])
with pytest.raises(Exception, match='has an invalid input amount'):
Blockchain.isValidTransactionChain(Blockchain3Blocks.chain)
def testTransaction():
senderWallet = Wallet()
recipient = 'recipient'
amount = 50
transaction = Trasaction(senderWallet, recipient, amount)
assert transaction.output[recipient] == amount
assert transaction.output[
senderWallet.address] == senderWallet.balance - amount
assert 'timestamp' in transaction.input
assert transaction.input['amount'] == senderWallet.balance
assert transaction.input['address'] == senderWallet.address
assert transaction.input['public_key'] == senderWallet.public_key
assert Wallet.verify(transaction.input['public_key'], transaction.output,
transaction.input['signature'])
def testTransactionUpdateBalance():
senderWallet = Wallet()
transc = Trasaction(senderWallet, 'recipient', 50)
with pytest.raises(Exception, match='Amount exceeds balance'):
transc.update(senderWallet, 'new_recipient', 9001)
def testVerifyValidSing():
data = {'foo': 'testData'}
wallet = Wallet()
signature = wallet.sign(data)
assert Wallet.verify(wallet.public_key, data, signature)
def postWalletTransaction(recipient, amount):
return request.POST(f'{URL}/wallet/transaction',
json={
'recipient': recipient,
'amount': amount
}).json()
def getWalletInfo():
return request.GET(f'{URL}/wallet/info').json()
startBlockchain = getBlockchain()
print(f'start_the_Blockchain:{startBlockchain()}')
recipient = Wallet().address
postWalletTransaction1 = postWalletTransaction(recipient, 21)
print(f'\n postWalletTransaction_1:{postWalletTransaction1}')
time.sleep(1)
postWalletTransaction2 = postWalletTransaction(recipient, 13)
print(f'\n postWalletTransaction_2:{postWalletTransaction2}')
time.sleep(1)
mineBlockValue = getBlockchainMine()
print(f'\n minedBlock:{mineBlockValue}')
walletInfo = getWalletInfo()
print(f'\nwalletInfo{walletInfo}')
def testValidTransactionWithInvalidSignature():
transaction = Trasaction(Wallet(), 'recipient', 50)
transaction.input['signature'] = Wallet().sign(transaction.output)
with pytest.raises(Exception, match='Invalid signature'):
Trasaction.isValidTransaction(transaction)
def testSetTransaction():
transactionPool = TransactionPool()
transaction = Trasaction(Wallet(), 'recipient', 1)
transactionPool.setTransaction(transaction)
assert transactionPool.transcationMap[transaction.id] == transaction
import os
import random
import requests
from flask import Flask, jsonify, request
from BackendSide.Blockchain.Blockchain import Blockchain
from BackendSide.Wallet.Transaction import Trasaction
from BackendSide.Wallet.wallet import Wallet
from BackendSide.Wallet.TransactionPool import TransactionPool
from BackendSide.PubNubSub import PubSub
app = Flask(__name__)
blockchain = Blockchain()
wallet = Wallet(blockchain)
transactionPool = TransactionPool()
pubsub = PubSub(blockchain, transactionPool)
@app.route('/')
def Default():
return 'Welcome to blockchain'
@app.route('/blockchain')
def routeBlockchain():
return jsonify(blockchain.to_json())
@app.route('/wallet/transaction', methods=['POST'])
def routeWalletTransacation():
# {'recipient': 'foo', 'amount': 15}
def testValidTransaction():
Trasaction.isValidTransaction(Trasaction(Wallet(), 'recipient', 50))
def testRewardTransaction():
minerWallet = Wallet()
transaction = Trasaction.rewardTransaction(minerWallet)
assert transaction.input == MINING_REWARD_INPUT
assert transaction.output[minerWallet.address] == MINING_REWARD
def testValidTransactionWithInvalidOutput():
senderWallet = Wallet()
transaction = Trasaction(senderWallet, 'recipient', 50)
transaction.output[senderWallet.address] = 9001
with pytest.raises(Exception, match='Invalid transaction output values'):
Trasaction.isValidTransaction(transaction)
def Blockchain3Blocks():
blockchain = Blockchain()
for i in range(3):
blockchain.addBlock([Trasaction(Wallet(), 'recipient', i).to_json()])
return blockchain
def testValidRewardTransaction():
rewardTransc = Trasaction.rewardTransaction(Wallet())
Trasaction.isValidTransaction(rewardTransc)
def testTransactionExceedsBalance():
with pytest.raises(Exception, match='Amount exceeds balance'):
Trasaction(Wallet(), 'recipient', 9001)
def testValidRewardTransactionExtraRecipient():
rewardTransc = Trasaction.rewardTransaction(Wallet())
rewardTransc.output['extraRecipient'] = 60
with pytest.raises(Exception, match='Invalid mining reward'):
Trasaction.isValidTransaction(rewardTransc)