Decide, Create, Publish and Repeat The Process

Decide, Create, Publish and Repeat the process. That’s how you learn coding. That’s how you get from newbie to master! That’s how you build those portfolio projects and get the job. That’s how you become a freelancer or an entrepreneur. That’s how you turn dreams into reality…

Hope you guys will enjoy this video and get inspired 🙂

Support the Channel 💙☕🙏
PayPal: https://paypal.me/CodingJourney

Affiliate Links*
Bluehost Web Hosting: https://www.bluehost.com/track/codingjourney/

*By making a purchase through any of my affiliate links, I’ll receive a small commission at no additional cost to you. This helps support the channel and allows me to continue creating videos like this. Thank you for your support!

Suggested Videos:
Giving myself a pat on the back (you should too): https://www.youtube.com/watch?v=AsuMzAFlVHM
Voice Search with JavaScript (Web Speech API): https://www.youtube.com/watch?v=kagZyM0wzJk
Marquee-like Content Scrolling (HTML & CSS): https://www.youtube.com/watch?v=sVZX0XvEBhk
JavaScript Loops: https://www.youtube.com/watch?v=rTDAAhUgJZM

Thanks for watching! For any questions, suggestions or just to say hi, please use the comment section below!

Codepen: https://codepen.io/Coding_Journey/
Twitter: https://twitter.com/CodingJrney
Email: codingjourney123@gmail.com

Subscribe 💖
https://www.youtube.com/channel/UCwpH4liYtBSiVXSfL8x2TyQ?sub_confirmation=1

#coding #portfolio

What is GEEK

Buddha Community

Decide, Create, Publish and Repeat The Process
Harry Patel

Harry Patel

1614145832

A Complete Process to Create an App in 2021

It’s 2021, everything is getting replaced by a technologically emerged ecosystem, and mobile apps are one of the best examples to convey this message.

Though bypassing times, the development structure of mobile app has also been changed, but if you still follow the same process to create a mobile app for your business, then you are losing a ton of opportunities by not giving top-notch mobile experience to your users, which your competitors are doing.

You are about to lose potential existing customers you have, so what’s the ideal solution to build a successful mobile app in 2021?

This article will discuss how to build a mobile app in 2021 to help out many small businesses, startups & entrepreneurs by simplifying the mobile app development process for their business.

The first thing is to EVALUATE your mobile app IDEA means how your mobile app will change your target audience’s life and why your mobile app only can be the solution to their problem.

Now you have proposed a solution to a specific audience group, now start to think about the mobile app functionalities, the features would be in it, and simple to understand user interface with impressive UI designs.

From designing to development, everything is covered at this point; now, focus on a prelaunch marketing plan to create hype for your mobile app’s targeted audience, which will help you score initial downloads.

Boom, you are about to cross a particular download to generate a specific revenue through your mobile app.

#create an app in 2021 #process to create an app in 2021 #a complete process to create an app in 2021 #complete process to create an app in 2021 #process to create an app #complete process to create an app

Siphiwe  Nair

Siphiwe Nair

1622608260

Making Sense of Unbounded Data & Real-Time Processing Systems

Unbounded data refers to continuous, never-ending data streams with no beginning or end. They are made available over time. Anyone who wishes to act upon them can do without downloading them first.

As Martin Kleppmann stated in his famous book, unbounded data will never “complete” in any meaningful way.

“In reality, a lot of data is unbounded because it arrives gradually over time: your users produced data yesterday and today, and they will continue to produce more data tomorrow. Unless you go out of business, this process never ends, and so the dataset is never “complete” in any meaningful way.”

— Martin Kleppmann, Designing Data-Intensive Applications

Processing unbounded data requires an entirely different approach than its counterpart, batch processing. This article summarises the value of unbounded data and how you can build systems to harness the power of real-time data.

#stream-processing #software-architecture #event-driven-architecture #data-processing #data-analysis #big-data-processing #real-time-processing #data-storage

CODE VN

CODE VN

1637564068

Xây dựng chuỗi khối tiền điện tử của riêng bạn bằng Python

Tiền điện tử là một loại tiền kỹ thuật số phi tập trung sử dụng các kỹ thuật mã hóa để điều chỉnh việc tạo ra các đơn vị tiền tệ và để xác minh việc chuyển tiền. Ẩn danh, phân quyền và bảo mật là một trong những tính năng chính của nó. Tiền điện tử không được quản lý hoặc theo dõi bởi bất kỳ cơ quan quản lý tập trung, chính phủ hoặc ngân hàng nào.

Blockchain, một mạng ngang hàng (P2P) phi tập trung, bao gồm các khối dữ liệu, là một phần không thể thiếu của tiền điện tử. Các khối này lưu trữ theo thứ tự thời gian thông tin về các giao dịch và tuân theo một giao thức để giao tiếp giữa các nút và xác nhận các khối mới. Dữ liệu được ghi trong các khối không thể bị thay đổi nếu không có sự thay đổi của tất cả các khối tiếp theo.

Trong bài viết này, chúng tôi sẽ giải thích cách bạn có thể tạo một chuỗi khối đơn giản bằng ngôn ngữ lập trình Python.

Đây là bản thiết kế cơ bản của lớp Python mà chúng tôi sẽ sử dụng để tạo blockchain:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Bây giờ, hãy giải thích cách hoạt động của lớp blockchain.

Cấu trúc ban đầu của lớp khối

Đây là mã cho lớp khối ban đầu của chúng tôi:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Như bạn có thể thấy ở trên, phương thức khởi tạo hoặc phương thức khởi tạo lớp ( init ()) ở trên nhận các tham số sau:

self- giống như bất kỳ lớp Python nào khác, tham số này được sử dụng để tham chiếu đến chính lớp đó. Bất kỳ biến nào được liên kết với lớp đều có thể được truy cập bằng cách sử dụng nó.

index - nó được sử dụng để theo dõi vị trí của một khối trong chuỗi khối.

previous_hash - nó được sử dụng để tham chiếu hàm băm của khối trước đó trong chuỗi khối.

data—it cung cấp thông tin chi tiết về các giao dịch đã thực hiện, chẳng hạn như số tiền đã mua.

timestamp—it chèn dấu thời gian cho tất cả các giao dịch được thực hiện.

Phương thức thứ hai trong lớp, compute_hash, được sử dụng để tạo ra hàm băm mật mã của mỗi khối dựa trên các giá trị trên.

Như bạn có thể thấy, chúng tôi đã nhập thuật toán SHA-256 vào dự án blockchain tiền điện tử để giúp lấy các hàm băm của các khối.

Khi các giá trị đã được đặt bên trong mô-đun băm, thuật toán sẽ trả về một chuỗi 256-bit biểu thị nội dung của khối.

Vì vậy, đây là những gì mang lại tính bất biến của blockchain. Vì mỗi khối sẽ được đại diện bởi một hàm băm, sẽ được tính toán từ hàm băm của khối trước đó, việc làm hỏng bất kỳ khối nào trong chuỗi sẽ khiến các khối khác có hàm băm không hợp lệ, dẫn đến việc toàn bộ mạng blockchain bị phá vỡ.

Xây dựng chuỗi

Toàn bộ khái niệm về blockchain dựa trên thực tế là các khối được “liên kết” với nhau. Bây giờ, chúng tôi sẽ tạo một lớp blockchain sẽ đóng vai trò quan trọng trong việc quản lý toàn bộ chuỗi.

Nó sẽ giữ dữ liệu giao dịch và bao gồm các phương pháp trợ giúp khác để hoàn thành các vai trò khác nhau, chẳng hạn như thêm các khối mới.

Hãy nói về các phương thức trợ giúp.

Thêm phương thức xây dựng

Đây là mã:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

Các init () phương thức khởi tạo là những gì instantiates blockchain.

Dưới đây là vai trò của các thuộc tính của nó:

self.chain - biến này lưu trữ tất cả các khối.

self.current_data - biến này lưu trữ thông tin về các giao dịch trong khối.

self.build_genesis () - phương thức này được sử dụng để tạo khối ban đầu trong chuỗi.

Xây dựng Khối Sáng thế

Các build_genesis()phương pháp được sử dụng để tạo khối ban đầu trong chuỗi, có nghĩa là, một khối mà không cần bất kỳ người tiền nhiệm. Khối genesis là thứ đại diện cho sự khởi đầu của blockchain.

Để tạo nó, chúng tôi sẽ gọi build_block()phương thức và cung cấp cho nó một số giá trị mặc định. Các tham số proof_numberprevious_hashcả hai đều có giá trị bằng 0, mặc dù bạn có thể cung cấp cho chúng bất kỳ giá trị nào bạn muốn.

Đây là mã:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Xác nhận tính hợp lệ của chuỗi khối

Các confirm_validityphương pháp là rất quan trọng trong việc kiểm tra tính toàn vẹn của blockchain và đảm bảo những mâu thuẫn đang thiếu.

Như đã giải thích trước đó, hàm băm đóng vai trò quan trọng trong việc nhận ra tính bảo mật của chuỗi khối tiền điện tử, bởi vì bất kỳ thay đổi nhỏ nào trong một đối tượng sẽ dẫn đến việc tạo ra một hàm băm hoàn toàn khác.

Do đó, confirm_validityphương pháp sử dụng một loạt các câu lệnh if để đánh giá xem liệu băm của mỗi khối có bị xâm phạm hay không.

Hơn nữa, nó cũng so sánh các giá trị băm của mỗi hai khối liên tiếp để xác định bất kỳ điểm bất thường nào. Nếu chuỗi hoạt động bình thường, nó trả về true; nếu không, nó trả về false.

Đây là mã:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Khai báo dữ liệu giao dịch

Các get_dataphương pháp rất quan trọng trong việc công bố các dữ liệu của các giao dịch trên một khối. Phương thức này nhận ba tham số (thông tin người gửi, thông tin người nhận và số tiền) và thêm dữ liệu giao dịch vào danh sách self.current_data.

Đây là mã:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Hiệu quả Bằng chứng Công việc

Trong công nghệ blockchain, Proof of Work (PoW) đề cập đến sự phức tạp liên quan đến việc khai thác hoặc tạo ra các khối mới trên blockchain.

Ví dụ: PoW có thể được triển khai bằng cách xác định một số giải quyết vấn đề bất cứ khi nào người dùng hoàn thành một số công việc tính toán. Bất kỳ ai trên mạng blockchain đều nên tìm số phức tạp để xác định nhưng dễ xác minh - đây là khái niệm chính của PoW.

Bằng cách này, nó không khuyến khích gửi thư rác và ảnh hưởng đến tính toàn vẹn của mạng.

Trong bài viết này, chúng tôi sẽ minh họa cách đưa thuật toán Proof of Work vào một dự án tiền điện tử blockchain.

Hoàn thiện với khối cuối cùng

Cuối cùng, phương thức trình trợ giúp mới nhất_block () được sử dụng để truy xuất khối cuối cùng trên mạng, thực sự là khối hiện tại.

Đây là mã:

def latest_block(self):
        return self.chain[-1]

Triển khai khai thác trên chuỗi khối

Bây giờ, đây là phần thú vị nhất!

Ban đầu, các giao dịch được lưu giữ trong danh sách các giao dịch chưa được xác minh. Khai thác đề cập đến quá trình đặt các giao dịch chưa được xác minh trong một khối và giải quyết vấn đề PoW. Nó có thể được gọi là công việc tính toán liên quan đến việc xác minh các giao dịch.

Nếu mọi thứ đã được tìm ra chính xác, một khối sẽ được tạo hoặc khai thác và kết hợp với các khối khác trong chuỗi khối. Nếu người dùng đã khai thác thành công một khối, họ thường được thưởng vì đã sử dụng tài nguyên máy tính của họ để giải quyết vấn đề PoW.

Đây là phương pháp khai thác trong dự án blockchain tiền điện tử đơn giản này:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Tóm lược

Đây là toàn bộ mã cho lớp blockchain tiền điện tử của chúng tôi bằng Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Bây giờ, chúng ta hãy thử chạy mã của mình để xem liệu chúng ta có thể tạo ra một số đồng tiền kỹ thuật số hay không…

Wow, nó hoạt động!

Phần kết luận

Đó là nó!

Chúng tôi hy vọng rằng bài viết này đã giúp bạn hiểu được công nghệ cơ bản cung cấp năng lượng cho các loại tiền điện tử như Bitcoin và Ethereum.

Chúng tôi chỉ minh họa những ý tưởng cơ bản để làm cho bạn chân ướt chân ráo trong công nghệ blockchain sáng tạo. Dự án trên vẫn có thể được cải tiến bằng cách kết hợp các tính năng khác để làm cho nó hữu ích và mạnh mẽ hơn.

Crie seu próprio blockchain de criptomoeda em Python

A criptomoeda é uma moeda digital descentralizada que usa técnicas de criptografia para regular a geração de unidades monetárias e para verificar a transferência de fundos. Anonimato, descentralização e segurança estão entre suas principais características. A criptomoeda não é regulamentada ou rastreada por nenhuma autoridade centralizada, governo ou banco.

Blockchain, uma rede ponto a ponto descentralizada (P2P), que é composta por blocos de dados, é parte integrante da criptomoeda. Esses blocos armazenam cronologicamente informações sobre transações e aderem a um protocolo para comunicação entre nós e validação de novos blocos. Os dados gravados em blocos não podem ser alterados sem a alteração de todos os blocos subsequentes.

Neste artigo, vamos explicar como você pode criar um blockchain simples usando a linguagem de programação Python.

Aqui está o projeto básico da classe Python que usaremos para criar o blockchain:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Agora, vamos explicar como a classe blockchain funciona.

Estrutura Inicial da Classe de Bloco

Aqui está o código para nossa classe de bloco inicial:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Como você pode ver acima, o construtor de classe ou método de iniciação ( init ()) acima usa os seguintes parâmetros:

self- assim como qualquer outra classe Python, este parâmetro é usado para se referir à própria classe. Qualquer variável associada à classe pode ser acessada usando-a.

index - é usado para rastrear a posição de um bloco dentro do blockchain.

previous_hash - usado para fazer referência ao hash do bloco anterior dentro do blockchain.

data—it dá detalhes das transações realizadas, por exemplo, a quantidade comprada.

timestamp—it insere um carimbo de data / hora para todas as transações realizadas.

O segundo método da classe, compute_hash, é usado para produzir o hash criptográfico de cada bloco com base nos valores acima.

Como você pode ver, importamos o algoritmo SHA-256 para o projeto blockchain de criptomoeda para ajudar a obter os hashes dos blocos.

Uma vez que os valores tenham sido colocados dentro do módulo de hashing, o algoritmo retornará uma string de 256 bits denotando o conteúdo do bloco.

Então, é isso que dá imutabilidade ao blockchain. Como cada bloco será representado por um hash, que será calculado a partir do hash do bloco anterior, corromper qualquer bloco da cadeia fará com que os outros blocos tenham hashes inválidos, resultando na quebra de toda a rede do blockchain.

Construindo a Rede

Todo o conceito de blockchain é baseado no fato de que os blocos são “encadeados” entre si. Agora, criaremos uma classe blockchain que desempenhará a função crítica de gerenciar toda a cadeia.

Ele manterá os dados das transações e incluirá outros métodos auxiliares para completar várias funções, como adicionar novos blocos.

Vamos falar sobre os métodos auxiliares.

Adicionando o Método do Construtor

Aqui está o código:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

O método do construtor init () é o que instancia o blockchain.

Aqui estão as funções de seus atributos:

self.chain - esta variável armazena todos os blocos.

self.current_data - esta variável armazena informações sobre as transações no bloco.

self.build_genesis () - este método é usado para criar o bloco inicial na cadeia.

Construindo o Bloco Genesis

O build_genesis()método é usado para criar o bloco inicial da cadeia, ou seja, um bloco sem predecessores. O bloco de gênese é o que representa o início do blockchain.

Para criá-lo, chamaremos o build_block()método e forneceremos alguns valores padrão. Os parâmetros proof_numbere previous_hashrecebem o valor zero, embora você possa fornecer qualquer valor que desejar.

Aqui está o código:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Confirmando a Validade do Blockchain

O confirm_validitymétodo é fundamental para examinar a integridade do blockchain e garantir que haja inconsistências.

Conforme explicado anteriormente, os hashes são essenciais para realizar a segurança do blockchain da criptomoeda, porque qualquer pequena alteração em um objeto resultará na criação de um hash totalmente diferente.

Assim, o confirm_validitymétodo utiliza uma série de declarações if para avaliar se o hash de cada bloco foi comprometido.

Além disso, ele também compara os valores de hash de cada dois blocos sucessivos para identificar quaisquer anomalias. Se a cadeia estiver funcionando corretamente, ele retorna verdadeiro; caso contrário, retorna falso.

Aqui está o código:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Declaração de dados de transações

O get_datamétodo é importante para declarar os dados das transações em um bloco. Este método usa três parâmetros (informações do remetente, informações do receptor e quantidade) e adiciona os dados da transação à lista self.current_data.

Aqui está o código:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Efetuando a Prova de Trabalho

Na tecnologia blockchain, Prova de Trabalho (PoW) se refere à complexidade envolvida na mineração ou geração de novos blocos no blockchain.

Por exemplo, o PoW pode ser implementado identificando um número que resolve um problema sempre que um usuário conclui algum trabalho de computação. Qualquer pessoa na rede blockchain deve achar o número complexo de identificar, mas fácil de verificar - este é o conceito principal de PoW.

Dessa forma, desestimula o spamming e compromete a integridade da rede.

Neste artigo, ilustraremos como incluir um algoritmo de Prova de Trabalho em um projeto de criptomoeda blockchain.

Finalizando com o Último Bloco

Finalmente, o método auxiliar latest_block () é usado para recuperar o último bloco na rede, que é na verdade o bloco atual.

Aqui está o código:

def latest_block(self):
        return self.chain[-1]

Implementando Blockchain Mining

Agora, esta é a seção mais emocionante!

Inicialmente, as transações são mantidas em uma lista de transações não verificadas. Mineração se refere ao processo de colocar as transações não verificadas em um bloco e resolver o problema de PoW. Pode ser referido como o trabalho de computação envolvido na verificação das transações.

Se tudo foi descoberto corretamente, um bloco é criado ou extraído e unido com os outros no blockchain. Se os usuários extraíram um bloco com sucesso, eles geralmente são recompensados ​​por usar seus recursos de computação para resolver o problema de PoW.

Aqui está o método de mineração neste projeto simples de blockchain de criptomoeda:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Resumo

Aqui está todo o código para nossa classe crypto blockchain em Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Agora, vamos tentar executar nosso código para ver se podemos gerar algumas moedas digitais ...

Uau, funcionou!

Conclusão

É isso!

Esperamos que este artigo tenha ajudado você a entender a tecnologia subjacente que alimenta criptomoedas como Bitcoin e Ethereum.

Acabamos de ilustrar as idéias básicas para deixar seus pés molhados na tecnologia inovadora de blockchain. O projeto acima ainda pode ser aprimorado incorporando outros recursos para torná-lo mais útil e robusto.

Construisez votre propre blockchain de crypto-monnaie en Python

La crypto-monnaie est une monnaie numérique décentralisée qui utilise des techniques de cryptage pour réguler la génération d'unités monétaires et vérifier le transfert de fonds. L'anonymat, la décentralisation et la sécurité font partie de ses principales caractéristiques. La crypto-monnaie n'est réglementée ou suivie par aucune autorité centralisée, gouvernement ou banque.

Blockchain, un réseau peer-to-peer décentralisé (P2P), composé de blocs de données, fait partie intégrante de la crypto-monnaie. Ces blocs stockent chronologiquement des informations sur les transactions et adhèrent à un protocole de communication inter-nœuds et de validation de nouveaux blocs. Les données enregistrées dans les blocs ne peuvent pas être modifiées sans la modification de tous les blocs suivants.

Dans cet article, nous allons expliquer comment créer une blockchain simple à l'aide du langage de programmation Python.

Voici le plan de base de la classe Python que nous utiliserons pour créer la blockchain :

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Maintenant, expliquons comment fonctionne la classe blockchain.

Structure initiale de la classe Block

Voici le code de notre classe de bloc initiale :

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Comme vous pouvez le voir ci-dessus, le constructeur de classe ou la méthode d'initiation ( init ()) ci-dessus prend les paramètres suivants :

self— comme toute autre classe Python, ce paramètre est utilisé pour faire référence à la classe elle-même. Toute variable associée à la classe est accessible en l'utilisant.

index - il est utilisé pour suivre la position d'un bloc dans la blockchain.

previous_hash — il faisait référence au hachage du bloc précédent dans la blockchain.

data—it donne des détails sur les transactions effectuées, par exemple, le montant acheté.

timestamp—it insère un horodatage pour toutes les transactions effectuées.

La deuxième méthode de la classe, compute_hash , est utilisée pour produire le hachage cryptographique de chaque bloc en fonction des valeurs ci-dessus.

Comme vous pouvez le voir, nous avons importé l'algorithme SHA-256 dans le projet de blockchain de crypto-monnaie pour aider à obtenir les hachages des blocs.

Une fois les valeurs placées dans le module de hachage, l'algorithme renvoie une chaîne de 256 bits indiquant le contenu du bloc.

C'est donc ce qui donne à la blockchain l'immuabilité. Étant donné que chaque bloc sera représenté par un hachage, qui sera calculé à partir du hachage du bloc précédent, la corruption de n'importe quel bloc de la chaîne fera que les autres blocs auront des hachages invalides, entraînant la rupture de l'ensemble du réseau blockchain.

Construire la chaîne

Tout le concept d'une blockchain est basé sur le fait que les blocs sont « enchaînés » les uns aux autres. Maintenant, nous allons créer une classe blockchain qui jouera le rôle essentiel de gestion de l'ensemble de la chaîne.

Il conservera les données des transactions et inclura d'autres méthodes d'assistance pour remplir divers rôles, tels que l'ajout de nouveaux blocs.

Parlons des méthodes d'aide.

Ajout de la méthode constructeur

Voici le code :

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

La méthode constructeur init () est ce qui instancie la blockchain.

Voici les rôles de ses attributs :

self.chain — cette variable stocke tous les blocs.

self.current_data — cette variable stocke des informations sur les transactions dans le bloc.

self.build_genesis() — cette méthode est utilisée pour créer le bloc initial de la chaîne.

Construire le bloc Genesis

La build_genesis()méthode est utilisée pour créer le bloc initial dans la chaîne, c'est-à-dire un bloc sans aucun prédécesseur. Le bloc de genèse est ce qui représente le début de la blockchain.

Pour le créer, nous appellerons la build_block()méthode et lui donnerons des valeurs par défaut. Les paramètres proof_numberet previous_hashreçoivent tous deux une valeur de zéro, bien que vous puissiez leur donner la valeur que vous désirez.

Voici le code :

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Confirmation de la validité de la blockchain

La confirm_validityméthode est essentielle pour examiner l'intégrité de la blockchain et s'assurer qu'il n'y a pas d'incohérences.

Comme expliqué précédemment, les hachages sont essentiels pour assurer la sécurité de la blockchain de crypto-monnaie, car toute légère modification d'un objet entraînera la création d'un hachage entièrement différent.

Ainsi, le confirm_validityprocédé utilise une série d'instructions if pour évaluer si le hachage de chaque bloc a été compromis.

De plus, il compare également les valeurs de hachage de tous les deux blocs successifs pour identifier toute anomalie. Si la chaîne fonctionne correctement, elle renvoie true ; sinon, il retourne faux.

Voici le code :

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Déclaration des données des transactions

La get_dataméthode est importante pour déclarer les données des transactions sur un bloc. Cette méthode prend trois paramètres (informations de l'expéditeur, informations du destinataire et montant) et ajoute les données de transaction à la liste self.current_data.

Voici le code :

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Effectuer la preuve de travail

Dans la technologie blockchain, la preuve de travail (PoW) fait référence à la complexité impliquée dans l'extraction ou la génération de nouveaux blocs sur la blockchain.

Par exemple, le PoW peut être mis en œuvre en identifiant un numéro qui résout un problème chaque fois qu'un utilisateur effectue un travail informatique. Toute personne sur le réseau blockchain devrait trouver le numéro complexe à identifier mais facile à vérifier - c'est le concept principal de PoW.

De cette façon, cela décourage le spam et compromet l'intégrité du réseau.

Dans cet article, nous allons illustrer comment inclure un algorithme de preuve de travail dans un projet de crypto-monnaie blockchain.

Finaliser avec le dernier bloc

Enfin, la méthode helper last_block() est utilisée pour récupérer le dernier bloc sur le réseau, qui est en fait le bloc actuel.

Voici le code :

def latest_block(self):
        return self.chain[-1]

Mise en œuvre du minage de la blockchain

Maintenant, c'est la section la plus excitante!

Initialement, les transactions sont conservées dans une liste de transactions non vérifiées. Le minage fait référence au processus consistant à placer les transactions non vérifiées dans un bloc et à résoudre le problème de PoW. Il peut être appelé le travail informatique impliqué dans la vérification des transactions.

Si tout a été compris correctement, un bloc est créé ou extrait et joint aux autres dans la blockchain. Si les utilisateurs ont réussi à exploiter un bloc, ils sont souvent récompensés pour avoir utilisé leurs ressources informatiques pour résoudre le problème de PoW.

Voici la méthode de minage dans ce projet simple de blockchain de crypto-monnaie :

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Sommaire

Voici le code complet de notre classe crypto blockchain en Python :

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Maintenant, essayons d'exécuter notre code pour voir si nous pouvons générer des pièces numériques…

Waouh, ça a marché !

Conclusion

C'est ça!

Nous espérons que cet article vous a aidé à comprendre la technologie sous-jacente qui alimente les crypto-monnaies telles que Bitcoin et Ethereum.

Nous venons d'illustrer les idées de base pour se mouiller les pieds dans la technologie innovante de la blockchain. Le projet ci-dessus peut encore être amélioré en incorporant d'autres fonctionnalités pour le rendre plus utile et robuste.