def add_block(self, transactions): prev_hash = (self.chain[len(self.chain)-1]).hash new_block = Bloco(transactions, prev_hash) new_block.gerar_hash() proof = self.proof_of_work(new_block) self.chain.append(new_block) return proof, new_block
def carrega_dados():
global blockchain
global transacao_aberta
try:
with open('blockchain.txt', mode='r', encoding='utf-8') as arq:
# # pickle loads para arquivos binários / pickle loads for binary files
# # pickle não perde informações como o json no caso desta aplicação / pickle does not lose information like json in the case of this application
# conteudo_arquivo = pickle.loads(arq.read())
# print(conteudo_arquivo)
conteudo_arquivo = arq.readlines()
# blockchain = conteudo_arquivo['chain']
# transacao_aberta = conteudo_arquivo['ta']
blockchain = json.loads(conteudo_arquivo[0][:-1])
#blockchain = [{'hash_anterior': bloco['hash_anterior'], 'index': bloco['index'], 'prova': bloco['prova'], 'transacoes': []} por bloco in blockchain ]
blockchain_atualizado = []
for bloco in blockchain:
tx_convertido = [
Transacao(tx['remetente'], tx['destinatario'], tx['valor'])
for tx in bloco['transacoes']
]
# bloco atualizado utilizando class Bloco, block object
bloco_atualizado = Bloco(bloco['indice'],
bloco['hash_anterior'], tx_convertido,
bloco['prova'], bloco['seloTempo'])
blockchain_atualizado.append(bloco_atualizado)
blockchain = blockchain_atualizado
transacao_aberta = json.loads(conteudo_arquivo[1])
transacoes_atualizadas = []
for tx in transacao_aberta:
transacao_atualizada = Transacao(tx['remetente'],
tx['destinatario'],
tx['valor'])
transacoes_atualizadas.append(transacao_atualizada)
transacao_aberta = transacoes_atualizadas
except (IOError, IndexError):
print('Arquivo nao encontrado / File not found .')
# Inicializando a lista blockchain / Initializing the blockchain list
bloco_genesis = Bloco(0, '', [], 100, 0)
# Criação do blockchain como lista vazia / blockchain creation as empty list
blockchain = [bloco_genesis]
# Transações não tratadas / unhandled transactions
transacao_aberta = []
finally:
print('Limpeza / Wipe')
def addBlocoMT(self, nomeDoBloco, estadoInicial):
if self.existeBloco(nomeDoBloco):
oBloco = self.pegaOBloco(nomeDoBloco)
oBloco.inicial = estadoInicial
oBloco.estadoAtual = estadoInicial
return
# Cria novo bloco
novoBloco = Bloco(nomeDoBloco)
novoBloco.inicial = estadoInicial
novoBloco.estadoAtual = estadoInicial
self.blocos.append(novoBloco)
return novoBloco
def addBlocoMT(self, nomeDoBloco, estadoInicial):
# Se existir apenas retorna o bloco da lista de blocos
if self.existeBloco(nomeDoBloco):
oBloco = self.pegaOBloco(nomeDoBloco)
oBloco.inicial = estadoInicial
oBloco.estadoAtual = estadoInicial
return oBloco
# Cria novo bloco
novoBloco = Bloco(nomeDoBloco)
novoBloco.inicial = estadoInicial
novoBloco.estadoAtual = estadoInicial
self.blocos.append(novoBloco)
return novoBloco
def mine_block():
# busca o ultimo bloco corrente do blockchain / search the last block block
ultimo_bloco = blockchain[-1]
# hash do ultimo bloco, para comparar com o valor guardado / hash of the last block, to compare with the saved value
bloco_hashed = Hash_util.hash_bloco(ultimo_bloco)
# print(bloco_hashed)
prova = prova_trabalho()
# transação de recompensa para os mineradores / reward transaction for miners
"""transacao_recompensa ={
'remetente': 'MINERACAO',
'destinatario': proprietario,
'valor': RECOMPENSA_MINERACAO
}"""
#!!!!!!!!!!!!!!!!!
transacao_recompensa = Transacao('MINERACAO', proprietario,
RECOMPENSA_MINERACAO)
# cria uma nova lista igual a lista de transação aberta, para nao manipular a lista original de transação aberta
# created a new list equal to the open transaction list, so as not to manipulate the original open transaction list
transacao_copiada = transacao_aberta[:]
transacao_copiada.append(transacao_recompensa)
#class bloco
bloco = Bloco(len(blockchain), bloco_hashed, transacao_copiada, prova)
blockchain.append(bloco)
#print(proprietario)
#print(obtem_saldo(proprietario))
return True
def __init__(self, nsets, bsize, assoc, pol):
self.nsets = nsets
self.bsize = bsize
self.assoc = assoc
self.cache = []
self.fifo = []
self.lru = []
self.missComp = 0
self.missCap = 0
self.missConf = 0
self.acess = 0
self.hits = 0
self.pol = pol
for i in range(assoc):
self.cache.insert(i, [])
for j in range(nsets):
self.cache[i].insert(j, Bloco())
for i in range(0, self.nsets):
self.fifo.insert(i, [])
self.lru.insert(i, [])
def leia_data(self):
try:
with open('blockchain.txt', mode='r') as leia:
'''PICKLE'''
# conteudo_arquivo = pickle.loads(leia.read())
'''JSON'''
conteudo_arquivo = leia.readlines()
# blockchain = conteudo_arquivo['chain']
# transacoes_abertas = conteudo_arquivo['transacao_aberta']
blockchain = json.loads(conteudo_arquivo[0][:-1])
blockchain_atualizado = []
for block in blockchain:
tx_conversao = [
Transacoes(tx['pagador'], tx['recebedor'],
tx['assinatura'], tx['valor'])
for tx in block['transacoes']
]
bloco_atualizado = Bloco(block['index'],
block['hash_antiga'],
tx_conversao, block['prova'],
block['timestamp'])
blockchain_atualizado.append(bloco_atualizado)
self.chain = blockchain_atualizado
transacoes_abertas = json.loads(conteudo_arquivo[1])
transacoes_atualizadas = []
for tx in transacoes_abertas:
transacoes_atualizada = Transacoes(tx['pagador'],
tx['recebedor'],
tx['assinatura'],
tx['valor'])
transacoes_atualizadas.append(transacoes_atualizada)
self.__transacoes_abertas = transacoes_atualizadas
except (IOError, IndexError):
print('Exceção concedida!')
pass
finally:
print('Tudo certo.')
def criar_blocos(self):
self.lista_blocos = [
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (250, 200),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (550, 200),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (250, 450),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (550, 450),
str(self.gerar_numeros()))
]
self.bloco_principal = Bloco(self.amb, self.screen, self.local_img,
"bloco_resposta.png", (225, 0),
self.questao)
def salve_data(self):
try:
with open('blockchain.txt', mode='w') as arquivo:
'''JSON'''
chain_salvavel = [
bloco.__dict__ for bloco in [
Bloco(bloco_el.index, bloco_el.hash_antiga,
[tx.__dict__ for tx in bloco_el.transacoes],
bloco_el.prova, bloco_el.timestamp)
for bloco_el in self.__chain
]
]
arquivo.write(json.dumps(chain_salvavel))
arquivo.write('\n')
tx_salvavel = [tx.__dict__ for tx in self.__transacoes_abertas]
arquivo.write(json.dumps(tx_salvavel))
'''PICKLE'''
# salve_data = {
# 'chain': blockchain,
# 'transacao_aberta': transacoes_abertas
# }
# arquivo.write(pickle.dumps(salve_data))
except IOError:
print('Salvar falhou..')
def minere_blocos(self):
if self.id_node == None:
return None
ultimo_bloco = self.__chain[-1]
hashed_bloco = block_hash(ultimo_bloco)
prova = self.prova_de_trabalho()
# reconpensa_transacao = {
# 'pagador': 'Mineracao',
# 'recebedor': dono,
# 'valor': reconpensa_mineracao
# }
reconpensa_transacao = Transacoes('Mineracao', self.id_node, '',
reconpensa_mineracao)
transacao_copiadas = self.__transacoes_abertas[:]
for tx in transacao_copiadas:
if not Wallet.verificar_tx(tx):
return None
transacao_copiadas.append(reconpensa_transacao)
bloco = Bloco(len(self.__chain), hashed_bloco, transacao_copiadas,
prova)
self.__chain.append(bloco)
self.__transacoes_abertas = []
self.salve_data()
return bloco
def salvar_dados():
try:
#mode w for json, mode wb for binary
#extension .p => binary , .txt => json
with open('blockchain.txt', mode='w') as arq:
#problemas para gravar em formato json, a função não consegue serializar para o dump
saveapto_blockchain = [
bloco.__dict__ for bloco in [
Bloco(elemBloco.indice, elemBloco.hash_anterior,
[tx.__dict__ for tx in elemBloco.transacoes],
elemBloco.prova, elemBloco.seloTempo)
for elemBloco in blockchain
]
]
arq.write(json.dumps(saveapto_blockchain))
arq.write('\n')
print(saveapto_blockchain)
saveapto_tx = [tx.__dict__ for tx in transacao_aberta]
arq.write(json.dumps(saveapto_tx))
print('Blockchain salvo com sucesso')
except IOError:
print('Erro ao gravar o blockchain')
BRANCO = (255, 255, 255)
VERMELHO = (255, 0, 0)
VERDE = (0, 255, 0)
AZUL = (0, 0, 255)
PRETO = (0, 0, 0)
pygame.init()
tela = pygame.display.set_mode((LARGURA, ALTURA))
pygame.display.set_caption("CORRE")
fonte = pygame.font.SysFont("comicsansms", 30)
listaSprites = pygame.sprite.Group()
personagem = Bloco(BRANCO, 20, 20, 150, 450)
x = random.randrange(LARGURA - 40)
y = random.randrange(0,300)
inimigos = Bloco(VERMELHO, 40, 20, x, y)
lista = []
lista.append(inimigos)
listaSprites.add(personagem)
listaSprites.add(inimigos)
sair = False
bateu = False
i = 0
j = 0
texto = fonte.render("Pontos: " + str(pontos), True, (BRANCO))
class GeradorBlocos(object):
lista_blocos = []
resposta = 0
def __init__(self, amb, screen, local_img, operacao):
self.amb = amb
self.screen = screen
self.local_img = local_img
self.operacao = operacao
self.tratar_operacao()
self.criar_blocos()
self.lista_blocos[randint(0, 3)].gerar_texto(str(self.resposta))
def tratar_operacao(self):
if self.operacao == "adicao":
numero1 = randint(0, 20)
numero2 = randint(0, 20)
self.resposta = numero1 + numero2
self.questao = (str(numero1) + " + " + str(numero2))
def gerar_numeros(self):
num = randint(0, 20)
while num == self.resposta:
num = randint(0, 20)
return num
def tratar_eventos(self, clique, pos_mouse):
for bloco in self.lista_blocos:
if bloco.rect_objeto.collidepoint(pos_mouse):
bloco.img = "alternativa.png"
bloco.carregar_objeto()
if clique == (1, 0, 0):
print(int(bloco.num))
if int(bloco.num) == self.resposta:
print("Voce acertou, parabens!")
else:
print("Voce errou, otario!")
else:
bloco.img = "bloco_alternativa.png"
bloco.carregar_objeto()
# TEMPORARIO - iSSO É UM TESTE
def criar_blocos(self):
self.lista_blocos = [
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (250, 200),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (550, 200),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (250, 450),
str(self.gerar_numeros())),
Bloco(self.amb, self.screen,
self.local_img, "bloco_alternativa.png", (550, 450),
str(self.gerar_numeros()))
]
self.bloco_principal = Bloco(self.amb, self.screen, self.local_img,
"bloco_resposta.png", (225, 0),
self.questao)
def desenhar(self):
for bloco in self.lista_blocos:
bloco.desenhar()
self.bloco_principal.desenhar()
def add_bloco(self, transacoes):
hash_anterior = (self.chain[len(self.chain) - 1]).hash
new_bloco = Bloco(transacoes, hash_anterior)
new_bloco.gerar_hash()
# prova = prova_de_trabalho(bloco)
self.chain.append(new_bloco)
def genesis_bloco(self):
transacoes = []
genesis_bloco = Bloco(transacoes, "0")
genesis_bloco.gerar_hash()
self.chain.append(genesis_bloco)
def genesis_block(self): transactions = [] first_block = Bloco(transactions, "0") first_block.gerar_hash() self.chain.append(first_block)
def __init__(self, id_node):
genesis_bloco = Bloco(0, '', [], 100, 0)
self.chain = [genesis_bloco]
self.__transacoes_abertas = []
self.leia_data()
self.id_node = id_node