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 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 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 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 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 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 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 isValidTransaction(transaction):
"""
Validate a transac
Raise a exception for invalid transaction
Sprawdź poprawność transakcji
Podnieś wyjątek dla nieprawidłowej transakcji
"""
if transaction.input == MINING_REWARD_INPUT:
if list(transaction.output.values()) != [MINING_REWARD]:
raise Exception('Invalid mining reward')
return
outputTotal = sum(transaction.output.values())
if transaction.input['amount'] != outputTotal:
raise Exception('Invalid transaction output values')
if not Wallet.verify(transaction.input['public_key'],
transaction.output,
transaction.input['signature']):
raise Exception('Invalid signature')
def testVerifyValidSing():
data = {'foo': 'testData'}
wallet = Wallet()
signature = wallet.sign(data)
assert Wallet.verify(wallet.public_key, data, signature)
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 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}')
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 testSetTransaction():
transactionPool = TransactionPool()
transaction = Trasaction(Wallet(), 'recipient', 1)
transactionPool.setTransaction(transaction)
assert transactionPool.transcationMap[transaction.id] == transaction
def testTransactionUpdateBalance():
senderWallet = Wallet()
transc = Trasaction(senderWallet, 'recipient', 50)
with pytest.raises(Exception, match='Amount exceeds balance'):
transc.update(senderWallet, 'new_recipient', 9001)
def Blockchain3Blocks():
blockchain = Blockchain()
for i in range(3):
blockchain.addBlock([Trasaction(Wallet(), 'recipient', i).to_json()])
return blockchain
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 testTransactionExceedsBalance():
with pytest.raises(Exception, match='Amount exceeds balance'):
Trasaction(Wallet(), 'recipient', 9001)
def testValidTransaction():
Trasaction.isValidTransaction(Trasaction(Wallet(), 'recipient', 50))
def testValidRewardTransactionExtraRecipient():
rewardTransc = Trasaction.rewardTransaction(Wallet())
rewardTransc.output['extraRecipient'] = 60
with pytest.raises(Exception, match='Invalid mining reward'):
Trasaction.isValidTransaction(rewardTransc)
def testValidRewardTransaction():
rewardTransc = Trasaction.rewardTransaction(Wallet())
Trasaction.isValidTransaction(rewardTransc)
def testRewardTransaction():
minerWallet = Wallet()
transaction = Trasaction.rewardTransaction(minerWallet)
assert transaction.input == MINING_REWARD_INPUT
assert transaction.output[minerWallet.address] == MINING_REWARD
