def test_invalid_hash(self):
data = {'message': 'this is the genesis block'}
genesis_block = GenesisBlock(data)
self.chain.append(genesis_block)
rogue_data = {'message': 'this is a different genesis block'}
rogue_genesis_block = GenesisBlock(rogue_data)
data = {'message': 'this is a test'}
next_block = rogue_genesis_block.next(data)
next_block.timestamp = genesis_block.timestamp + 100
with self.assertRaises(BlockHashDontMatchException):
self.chain.append(next_block)
def set_genesis(self, public_key, num_zeros, num_transactions):
pk_bytes = bytes.fromhex(public_key)
public_key = load_pem_public_key(pk_bytes, backend=default_backend())
self.genesis_block = GenesisBlock(public_key, "", num_zeros,
num_transactions + 1)
logical_block = LogicalBlock("", 0, None, None)
logical_block.block = self.genesis_block
self.blockchain = [logical_block]
self.blockheaders = []
# wallet metadata on blockchain
self.cur_coins_from_issuer = {}
self.cur_coins_from_voter = {}
self.pending_transactions = []
self.interrupt_mining = 1
self.issuer_id = public_key
self.transactions_per_block = num_transactions
self.mining_thread = None
if self.mining_thread:
self.mining_thread.terminate() # BAD
self.mining_thread = None
self.is_mining = False
self.mining_transactions = []
self.recieved_new_block = False
def setUp(self):
data = {
'message': 'this is the genesis block'
}
self.genesis_block = GenesisBlock(data)
service = Node(port=5559, genesis_block=self.genesis_block)
threading.Thread(target=service.serve).start()
self.node = service
self.connect('localhost:5559')
def test_invalid_timestamp(self):
data = {'message': 'this is the genesis block'}
genesis_block = GenesisBlock(data)
self.chain.append(genesis_block)
data = {'message': 'this is a test'}
next_block = genesis_block.next(data)
next_block.timestamp = genesis_block.timestamp - 100
with self.assertRaises(BlocksNotSequentialException):
self.chain.append(next_block)
def block_from_data(source):
index = source.get('index')
if index == 0:
return GenesisBlock(source.get('data'),
source.get('timestamp'))
return Block(index,
source.get('previous_hash'),
source.get('data'),
source.get('timestamp'))
def test_invalid_index(self):
data = {'message': 'this is the genesis block'}
genesis_block = GenesisBlock(data)
self.chain.append(genesis_block)
data = {'message': 'this is a test'}
next_block = genesis_block.next(data)
next_block.timestamp = genesis_block.timestamp + 100
genesis_block.index = 5
with self.assertRaises(BlocksNotCorrelativeException):
self.chain.append(next_block)
def addGenesis(self):
"""
Add genesis block the blockchain as the first block.
- Create Genesis Block
- Add it to the blockmap and set the chain graph.
"""
self.primary_blockchain_block = GenesisBlock()
self.blockmap[self.primary_blockchain_block.blockhash] = self.primary_blockchain_block
self._chaingraph[self.primary_blockchain_block.blockhash] = set()
self.max_height = 1
def mine():
if len(blockchain) == 0:
genesis_block = GenesisBlock(miner_pub_key=miner_key)
genesis_block.mine(blockchain.get_difficult())
blockchain.add(genesis_block)
else:
block = Block(previous_block=blockchain.chain[-1], miner_pub_key=miner_key, \
transactions=transactionPool.get_best_transactions(blockchain,1))
block.mine(blockchain.get_difficult())
blockchain.add(block)
send_blockchain()
return ''
def test_peer_cant_import_different_network(self):
new_block = self.genesis_block.next({"message": "second block"})
node_a = self.nodes.get('a')
node_a.chain.append(new_block)
self.assertEqual(len(node_a.chain), 2)
data = {'message': 'this is not the same genesis block'}
rogue_genesis_work = GenesisBlock(data)
node_c = self.create_node('c',
port=35558,
genesis_block=rogue_genesis_work,
peers=['localhost:35555'])
self.assertEqual(len(node_c.peers), 1)
self.assertEqual(len(node_c.chain), 1)
def test_adding_blocks(self):
data = {'message': 'this is the genesis block'}
genesis_block = GenesisBlock(data)
data = {'message': 'this is a test'}
self.chain.append(genesis_block)
next_block = Block(1, "000", data)
next_block.timestamp = genesis_block.timestamp + 100
next_block.data = {'message': 'this is a modified genesis block'}
with self.assertRaises(BlockHashDontMatchException):
self.chain.append(next_block)
next_block.previous_hash = genesis_block.hash
self.chain.append(next_block)
self.assertIn(next_block, self.chain)
self.assertIn(genesis_block, self.chain)
def __init__(self, label=None):
# Labeling
self.nodeType = "Basic"
self.label = label
(sk, pk) = generateKeyPair()
self.privateKey = sk
self.uncompressedPublicKey = pk
cpk = compressPublicKey(pk)
self.publicKey = cpk
self.address = encode(cpk)
self.peers = set()
self.memPool = []
self.blocks = {}
# hardcode the first block into client nodes
genesis = GenesisBlock()
self.blocks[genesis.blockHeader.blockHash()] = genesis
def blockchain():
blockchain = Blockchain()
private_keys = [43, 53, 63]
public_keys = mapv(lambda priv: PrivateKey(priv).public_key().to_bytes(),
private_keys)
genesis_block = GenesisBlock(miner_pub_key=public_keys[0])
genesis_block.mine(blockchain.get_difficult())
blockchain.add(genesis_block)
miners = [public_keys[1], public_keys[2]]
outputs_array = [[(public_keys[0], 1), (public_keys[1], 2)],
[(public_keys[2], 10), (public_keys[1], 1)]]
for key, miner, outputs in zip(private_keys, miners, outputs_array):
transaction = Wallet(key).sign(Transaction(outputs))
block = Block(blockchain.get_last_block(), [transaction],
miner_pub_key=miner)
block.mine(blockchain.get_difficult())
blockchain.add(block)
return blockchain
def setUp(self):
self.nodes = {}
data = {'message': 'this is the genesis block'}
self.genesis_block = GenesisBlock(data)
self.create_node('a', port=35555)
self.create_node('b', port=35556)
from . import Node
from block import GenesisBlock
from os import environ
data = {'message': 'this is the genesis block'}
genesis_block = GenesisBlock(data)
try:
port = int(environ.get('PORT', None))
except ValueError:
port = 80
Node(port=port, genesis_block=genesis_block).serve()
def _genesis(self):
block = GenesisBlock()
self.accept_block(block)