Mark Mara

Mark Mara

1608707589

Creates a PNG from Recharts Components

recharts-to-png

For Recharts 1.X

Uses html2canvas to convert a Recharts chart to PNG.

Inspired by these Stack Overflow questions and answers from peter.bartos and AlbertMunichMar.

Install

npm install recharts-to-png

Hook

The recommended way of using recharts-to-png. It is compatible with React 16.8+, does not rely on findDOMNode, and is required for React 17:

import { useRechartToPng } from "recharts-to-png";

function MyComponent() {
  // Attach ref to a Recharts component, and the png will be returned
  // Also accepts an optional argument for Html2Canvas options: useRechartToPng(options)
  const [png, ref] = useRechartToPng();

  const handleDownload = React.useCallback(async () => {
    FileSaver.saveAs(png, "myChart.png");
  }, [png]);

  return (
    <LineChart ref={ref} ... />
  )
}

Deprecated

The original getPngData function this library offered does not work with React 17 (see #6). This section is still included for backwards compatibility, but will probably be removed at some point along with getPngData.

Demo

See a demo using recharts-to-png alongside FileSaver.

Usage
// chart: Element | React.Component | AreaChart | BarChart | PieChart | etc.
await getPngData(chart);

Allows all html2canvas configuration options to be passed:

await getPngData(chart, options);
Example
function App() {
  // The chart that we want to download the PNG for.
  const [chart, setChart] = React.useState();

  const handleDownload = React.useCallback(async () => {
    if (chart !== undefined) {
      // Send the chart to getPngData
      const pngData = await getPngData(chart);
      // Use FileSaver to download the PNG
      FileSaver.saveAs(pngData, 'test.png');
    }
  }, [chart]);

  const data = [...];

  return (
    <>
      <LineChart
        ref={(ref) => setChart(ref)} // Set target element
        data={data}
        height={300}
        width={600}
      >
        <XAxis dataKey="name" />
        <YAxis />
        <CartesianGrid strokeDasharray="3 3" />
        <Tooltip />
        <Legend wrapperStyle={{ bottom: 0 }} />
        <Line type="monotone" dataKey="pv" stroke="#8884d8" activeDot={{ r: 8 }} />
        <Line type="monotone" dataKey="uv" stroke="#82ca9d" />
      </LineChart>
      <span style={{ float: 'left' }}>
        <button onClick={handleDownload}>Download</button>
      </span>
    </>
  );
}

Download Details:

Author: brammitch

Source Code: https://github.com/brammitch/recharts-to-png

#react #reactjs #javascript

What is GEEK

Buddha Community

Creates a PNG from Recharts Components
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

How To Create a Blazor Component

In this video, we’re going to learn how to create a Blazor component for a Blazor application. We create a template and write C# code to connect the component with the application.

#how #to #create #blazor #component

Cree su propia cadena de bloques de criptomonedas en Python

La criptomoneda es una moneda digital descentralizada que utiliza técnicas de cifrado para regular la generación de unidades monetarias y verificar la transferencia de fondos. El anonimato, la descentralización y la seguridad se encuentran entre sus principales características. La criptomoneda no está regulada ni rastreada por ninguna autoridad centralizada, gobierno o banco.

Blockchain, una red descentralizada de igual a igual (P2P), que se compone de bloques de datos, es una parte integral de la criptomoneda. Estos bloques almacenan cronológicamente información sobre transacciones y se adhieren a un protocolo para la comunicación entre nodos y la validación de nuevos bloques. Los datos registrados en bloques no se pueden alterar sin la alteración de todos los bloques posteriores.

En este artículo, explicaremos cómo puede crear una cadena de bloques simple utilizando el lenguaje de programación Python.

Aquí está el plano básico de la clase Python que usaremos para crear la cadena de bloques:

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

Ahora, expliquemos cómo funciona la clase blockchain.

Estructura inicial de la clase de bloque

Aquí está el código para nuestra clase de bloque 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 puede ver arriba, el constructor de la clase o el método de iniciación ( init ()) anterior toma los siguientes parámetros:

self- al igual que cualquier otra clase de Python, este parámetro se utiliza para hacer referencia a la clase en sí. Se puede acceder a cualquier variable asociada con la clase usándola.

index - se usa para rastrear la posición de un bloque dentro de la cadena de bloques.

previous_hash - solía hacer referencia al hash del bloque anterior dentro de la cadena de bloques.

data—it da detalles de las transacciones realizadas, por ejemplo, la cantidad comprada.

timestamp—it inserta una marca de tiempo para todas las transacciones realizadas.

El segundo método de la clase, compute_hash, se utiliza para producir el hash criptográfico de cada bloque basándose en los valores anteriores.

Como puede ver, importamos el algoritmo SHA-256 al proyecto de cadena de bloques de criptomonedas para ayudar a obtener los valores hash de los bloques.

Una vez que los valores se han colocado dentro del módulo hash, el algoritmo devolverá una cadena de 256 bits que denota el contenido del bloque.

Entonces, esto es lo que le da inmutabilidad a la cadena de bloques. Dado que cada bloque estará representado por un hash, que se calculará a partir del hash del bloque anterior, la corrupción de cualquier bloque de la cadena hará que los otros bloques tengan hash no válidos, lo que provocará la rotura de toda la red blockchain.

Construyendo la Cadena

Todo el concepto de una cadena de bloques se basa en el hecho de que los bloques están "encadenados" entre sí. Ahora, crearemos una clase de blockchain que desempeñará el papel fundamental de administrar toda la cadena.

Mantendrá los datos de las transacciones e incluirá otros métodos auxiliares para completar varios roles, como agregar nuevos bloques.

Hablemos de los métodos de ayuda.

Agregar el método constructor

Aquí está el código:

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

El método constructor init () es lo que crea una instancia de la cadena de bloques.

Aquí están los roles de sus atributos:

self.chain : esta variable almacena todos los bloques.

self.current_data : esta variable almacena información sobre las transacciones en el bloque.

self.build_genesis () : este método se utiliza para crear el bloque inicial en la cadena.

Construyendo el Bloque Génesis

El build_genesis()método se utiliza para crear el bloque inicial en la cadena, es decir, un bloque sin predecesores. El bloque de génesis es lo que representa el comienzo de la cadena de bloques.

Para crearlo, llamaremos al build_block()método y le daremos algunos valores predeterminados. A los parámetros proof_numbery se previous_hashles asigna un valor de cero, aunque puede darles el valor que desee.

Aquí está el 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

Confirmación de la validez de Blockchain

El confirm_validitymétodo es fundamental para examinar la integridad de la cadena de bloques y asegurarse de que falten inconsistencias.

Como se explicó anteriormente, los hash son fundamentales para darse cuenta de la seguridad de la cadena de bloques de criptomonedas, porque cualquier ligera alteración en un objeto resultará en la creación de un hash completamente diferente.

Por lo tanto, el confirm_validitymétodo utiliza una serie de declaraciones if para evaluar si el hash de cada bloque se ha visto comprometido.

Además, también compara los valores hash de cada dos bloques sucesivos para identificar cualquier anomalía. Si la cadena funciona correctamente, devuelve verdadero; de lo contrario, devuelve falso.

Aquí está el 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

Declaración de datos de transacciones

El get_datamétodo es importante para declarar los datos de las transacciones en un bloque. Este método toma tres parámetros (información del remitente, información del destinatario y monto) y agrega los datos de la transacción a la lista self.current_data.

Aquí está el código:

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

Efectuar la prueba de trabajo

En la tecnología blockchain, Proof of Work (PoW) se refiere a la complejidad involucrada en la minería o la generación de nuevos bloques en blockchain.

Por ejemplo, el PoW se puede implementar identificando un número que resuelve un problema cada vez que un usuario completa algún trabajo informático. Cualquiera en la red blockchain debería encontrar el número complejo de identificar pero fácil de verificar: este es el concepto principal de PoW.

De esta manera, desalienta el envío de spam y compromete la integridad de la red.

En este artículo, ilustraremos cómo incluir un algoritmo de Prueba de trabajo en un proyecto de criptomoneda blockchain.

Finalizando con el último bloque

Finalmente, el método auxiliar latest_block () se usa para recuperar el último bloque en la red, que en realidad es el bloque actual.

Aquí está el código:

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

Implementando Blockchain Mining

¡Ahora, esta es la sección más emocionante!

Inicialmente, las transacciones se mantienen en una lista de transacciones no verificadas. La minería se refiere al proceso de colocar las transacciones no verificadas en un bloque y resolver el problema de PoW. Puede denominarse el trabajo informático involucrado en la verificación de las transacciones.

Si todo se ha resuelto correctamente, se crea o extrae un bloque y se une con los demás en la cadena de bloques. Si los usuarios han extraído un bloque con éxito, a menudo se les recompensa por utilizar sus recursos informáticos para resolver el problema de PoW.

Aquí está el método de minería en este simple proyecto de cadena de bloques de criptomonedas:

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)

Resumen

Aquí está el código completo para nuestra clase de cadena de bloques de cifrado 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)

Ahora, intentemos ejecutar nuestro código para ver si podemos generar algunas monedas digitales ...

¡Vaya, funcionó!

Conclusión

¡Eso es!

Esperamos que este artículo le haya ayudado a comprender la tecnología subyacente que impulsa las criptomonedas como Bitcoin y Ethereum.

Acabamos de ilustrar las ideas básicas para mojarse los pies en la innovadora tecnología blockchain. El proyecto anterior aún se puede mejorar incorporando otras características para hacerlo más útil y robusto.

Создайте свой собственный блокчейн криптовалюты на Python

Криптовалюта - это децентрализованная цифровая валюта, в которой используются методы шифрования для регулирования генерации денежных единиц и проверки перевода средств. Анонимность, децентрализация и безопасность - одни из его основных характеристик. Криптовалюта не регулируется и не отслеживается каким-либо централизованным органом, правительством или банком.

Блокчейн, децентрализованная одноранговая (P2P) сеть, состоящая из блоков данных, является неотъемлемой частью криптовалюты. Эти блоки хранят информацию о транзакциях в хронологическом порядке и придерживаются протокола для межузловой связи и проверки новых блоков. Данные, записанные в блоках, не могут быть изменены без изменения всех последующих блоков.

В этой статье мы собираемся объяснить, как создать простой блокчейн с помощью языка программирования Python.

Вот базовый план класса Python, который мы будем использовать для создания блокчейна:

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

Теперь давайте объясним, как работает класс блокчейна.

Начальная структура класса блоков

Вот код нашего начального класса блока:

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()

Как вы можете видеть выше, конструктор класса или метод инициации ( init ()) выше принимает следующие параметры:

self- как и любой другой класс Python, этот параметр используется для ссылки на сам класс. С его помощью можно получить доступ к любой переменной, связанной с классом.

index - он используется для отслеживания положения блока в цепочке блоков.

previous_hash - он использовался для ссылки на хэш предыдущего блока в цепочке блоков.

data—it предоставляет подробную информацию о проведенных транзакциях, например, купленную сумму.

timestamp—it вставляет отметку времени для всех выполненных транзакций.

Второй метод в классе, compute_hash, используется для создания криптографического хэша каждого блока на основе вышеуказанных значений.

Как видите, мы импортировали алгоритм SHA-256 в проект блокчейна криптовалюты, чтобы помочь в получении хэшей блоков.

Как только значения будут помещены в модуль хеширования, алгоритм вернет 256-битную строку, обозначающую содержимое блока.

Итак, это то, что дает неизменяемость блокчейна. Поскольку каждый блок будет представлен хешем, который будет вычисляться из хеша предыдущего блока, повреждение любого блока в цепочке приведет к тому, что другие блоки будут иметь недопустимые хеши, что приведет к поломке всей сети блокчейна.

Построение цепочки

Вся концепция блокчейна основана на том факте, что блоки «связаны» друг с другом. Теперь мы создадим класс цепочки блоков, который будет играть важную роль в управлении всей цепочкой.

Он будет хранить данные транзакций и включать другие вспомогательные методы для выполнения различных ролей, таких как добавление новых блоков.

Поговорим о вспомогательных методах.

Добавление метода конструктора

Вот код:

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

Метод конструктора init () - это то, что создает экземпляр блокчейна.

Вот роли его атрибутов:

self.chain - в этой переменной хранятся все блоки.

self.current_data - в этой переменной хранится информация о транзакциях в блоке.

self.build_genesis () - этот метод используется для создания начального блока в цепочке.

Создание блока генезиса

build_genesis()Метод используется для создания начального блока в цепочке, то есть, блок без каких - либо предшественников. Блок генезиса - это то, что представляет собой начало блокчейна.

Чтобы создать его, мы вызовем build_block()метод и дадим ему значения по умолчанию. Оба параметра proof_numberи previous_hashимеют нулевое значение, хотя вы можете присвоить им любое значение, которое пожелаете.

Вот код:

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

Подтверждение действительности блокчейна

Этот confirm_validityметод имеет решающее значение для проверки целостности цепочки блоков и проверки отсутствия несоответствий.

Как объяснялось ранее, хэши имеют решающее значение для обеспечения безопасности блокчейна криптовалюты, потому что любое небольшое изменение в объекте приведет к созданию совершенно другого хэша.

Таким образом, confirm_validityметод использует серию операторов if для оценки того, был ли скомпрометирован хэш каждого блока.

Кроме того, он также сравнивает хеш-значения каждых двух последовательных блоков для выявления любых аномалий. Если цепочка работает правильно, возвращается истина; в противном случае возвращается false.

Вот код:

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

Объявление данных транзакций

get_dataМетод имеет важное значение в объявлении данных об операциях на блоке. Этот метод принимает три параметра (информацию об отправителе, информацию о получателе и сумму) и добавляет данные транзакции в список self.current_data.

Вот код:

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

Выполнение доказательства работы

В технологии блокчейн Proof of Work (PoW) относится к сложности, связанной с майнингом или генерацией новых блоков в блокчейне.

Например, PoW может быть реализован путем определения числа, которое решает проблему всякий раз, когда пользователь выполняет некоторую вычислительную работу. Любой в сети блокчейн должен найти номер сложным для идентификации, но легким для проверки - это основная концепция PoW.

Таким образом, это препятствует распространению спама и нарушению целостности сети.

В этой статье мы покажем, как включить алгоритм Proof of Work в проект криптовалюты на блокчейне.

Завершение с последним блоком

Наконец, вспомогательный метод latest_block () используется для получения последнего блока в сети, который на самом деле является текущим блоком.

Вот код:

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

Внедрение Blockchain Mining

Теперь это самый интересный раздел!

Изначально транзакции хранятся в списке непроверенных транзакций. Майнинг относится к процессу размещения непроверенных транзакций в блоке и решения проблемы PoW. Это можно назвать вычислительной работой, связанной с проверкой транзакций.

Если все было правильно выяснено, блок создается или добывается и объединяется вместе с другими в цепочке блоков. Если пользователи успешно добыли блок, они часто получают вознаграждение за использование своих вычислительных ресурсов для решения проблемы PoW.

Вот метод майнинга в этом простом проекте блокчейна криптовалюты:

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)

Резюме

Вот весь код нашего класса криптоблокчейна на 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)

Теперь давайте попробуем запустить наш код, чтобы посмотреть, сможем ли мы сгенерировать несколько цифровых монет ...

Вау, сработало!

Заключение

Вот и все!

Мы надеемся, что эта статья помогла вам понять базовую технологию, на которой работают такие криптовалюты, как Биткойн и Эфириум.

Мы просто проиллюстрировали основные идеи, как сделать ваши ноги влажными в инновационной технологии блокчейн. Вышеупомянутый проект все еще можно улучшить, добавив другие функции, чтобы сделать его более полезным и надежным.

Erstellen Sie Ihre eigene Kryptowährungs-Blockchain in Python

Kryptowährung ist eine dezentralisierte digitale Währung, die Verschlüsselungstechniken verwendet, um die Erzeugung von Währungseinheiten zu regulieren und den Geldtransfer zu überprüfen. Anonymität, Dezentralisierung und Sicherheit gehören zu seinen Hauptmerkmalen. Kryptowährung wird von keiner zentralisierten Behörde, Regierung oder Bank reguliert oder verfolgt.

Blockchain, ein dezentralisiertes Peer-to-Peer (P2P)-Netzwerk, das aus Datenblöcken besteht, ist ein wesentlicher Bestandteil der Kryptowährung. Diese Blöcke speichern chronologisch Informationen über Transaktionen und halten sich an ein Protokoll für die Kommunikation zwischen Knoten und die Validierung neuer Blöcke. Die in Blöcken aufgezeichneten Daten können nicht geändert werden, ohne dass alle nachfolgenden Blöcke geändert werden.

In diesem Artikel erklären wir, wie Sie mit der Programmiersprache Python eine einfache Blockchain erstellen können.

Hier ist die grundlegende Blaupause der Python-Klasse, die wir zum Erstellen der Blockchain verwenden:

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

Lassen Sie uns nun erklären, wie die Blockchain-Klasse funktioniert.

Ausgangsstruktur der Blockklasse

Hier ist der Code für unsere anfängliche Blockklasse:

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()

Wie Sie oben sehen können, nimmt der Klassenkonstruktor oder die Initiationsmethode ( init ()) die folgenden Parameter an:

self— Wie jede andere Python-Klasse wird dieser Parameter verwendet, um auf die Klasse selbst zu verweisen. Auf jede Variable, die der Klasse zugeordnet ist, kann über sie zugegriffen werden.

index — Es wird verwendet, um die Position eines Blocks innerhalb der Blockchain zu verfolgen.

previous_hash — Es wurde verwendet, um auf den Hash des vorherigen Blocks innerhalb der Blockchain zu verweisen.

data—it gibt Details zu den getätigten Transaktionen an, zum Beispiel den gekauften Betrag.

timestamp—it fügt einen Zeitstempel für alle durchgeführten Transaktionen ein.

Die zweite Methode in der Klasse, compute_hash , wird verwendet, um den kryptografischen Hash jedes Blocks basierend auf den obigen Werten zu erzeugen.

Wie Sie sehen können, haben wir den SHA-256-Algorithmus in das Kryptowährungs-Blockchain-Projekt importiert, um die Hashes der Blöcke zu erhalten.

Sobald die Werte im Hashing-Modul platziert wurden, gibt der Algorithmus einen 256-Bit-String zurück, der den Inhalt des Blocks angibt.

Das ist es, was der Blockchain Unveränderlichkeit verleiht. Da jeder Block durch einen Hash repräsentiert wird, der aus dem Hash des vorherigen Blocks berechnet wird, führt die Beschädigung eines Blocks in der Kette dazu, dass die anderen Blöcke ungültige Hashes haben, was zum Bruch des gesamten Blockchain-Netzwerks führt.

Aufbau der Kette

Das ganze Konzept einer Blockchain basiert darauf, dass die Blöcke aneinander „verkettet“ sind. Jetzt erstellen wir eine Blockchain-Klasse, die die entscheidende Rolle bei der Verwaltung der gesamten Kette spielt.

Es behält die Transaktionsdaten bei und enthält andere Hilfsmethoden zum Vervollständigen verschiedener Rollen, z. B. das Hinzufügen neuer Blöcke.

Sprechen wir über die Hilfsmethoden.

Hinzufügen der Konstruktormethode

Hier ist der Code:

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

Die Konstruktormethode init () instanziiert die Blockchain.

Hier sind die Rollen seiner Attribute:

self.chain — Diese Variable speichert alle Blöcke.

self.current_data — Diese Variable speichert Informationen über die Transaktionen im Block.

self.build_genesis() — Diese Methode wird verwendet, um den Anfangsblock in der Kette zu erstellen.

Aufbau des Genesis-Blocks

Die build_genesis()Methode wird verwendet, um den Anfangsblock in der Kette zu erstellen, dh einen Block ohne Vorgänger. Der Genesis-Block ist der Anfang der Blockchain.

Um es zu erstellen, rufen wir die build_block()Methode auf und geben ihr einige Standardwerte. Die Parameter proof_numberund previous_hasherhalten beide den Wert Null, Sie können ihnen jedoch jeden beliebigen Wert zuweisen.

Hier ist der 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

Bestätigung der Gültigkeit der Blockchain

Die confirm_validityMethode ist entscheidend, um die Integrität der Blockchain zu überprüfen und sicherzustellen, dass Inkonsistenzen fehlen.

Wie bereits erwähnt, sind Hashes von entscheidender Bedeutung für die Realisierung der Sicherheit der Kryptowährungs-Blockchain, da jede geringfügige Änderung an einem Objekt zur Erstellung eines völlig anderen Hashs führt.

Somit verwendet das confirm_validityVerfahren eine Reihe von if-Anweisungen, um zu beurteilen, ob der Hash jedes Blocks kompromittiert wurde.

Darüber hinaus vergleicht es auch die Hash-Werte von jeweils zwei aufeinanderfolgenden Blöcken, um Anomalien zu identifizieren. Wenn die Kette richtig funktioniert, gibt sie true zurück; Andernfalls wird false zurückgegeben.

Hier ist der 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

Deklarieren von Transaktionsdaten

Die get_dataMethode ist wichtig, um die Daten von Transaktionen in einem Block zu deklarieren. Diese Methode verwendet drei Parameter (Absenderinformationen, Empfängerinformationen und Betrag) und fügt die Transaktionsdaten zur Liste self.current_data hinzu.

Hier ist der Code:

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

Bewirken des Arbeitsnachweises

In der Blockchain-Technologie bezieht sich Proof of Work (PoW) auf die Komplexität, die mit dem Mining oder der Generierung neuer Blöcke auf der Blockchain verbunden ist.

Zum Beispiel kann das PoW implementiert werden, indem eine Zahl identifiziert wird, die ein Problem löst, wenn ein Benutzer eine Rechenarbeit abschließt. Jeder im Blockchain-Netzwerk sollte den Zahlenkomplex identifizieren, aber leicht zu überprüfen finden – dies ist das Hauptkonzept von PoW.

Auf diese Weise verhindert es Spam und gefährdet die Integrität des Netzwerks.

In diesem Artikel veranschaulichen wir, wie Sie einen Proof of Work-Algorithmus in ein Blockchain-Kryptowährungsprojekt einbinden.

Abschluss mit dem letzten Block

Schließlich wird die Hilfsmethode Latest_block() verwendet, um den letzten Block im Netzwerk abzurufen, der tatsächlich der aktuelle Block ist.

Hier ist der Code:

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

Implementieren von Blockchain-Mining

Das ist jetzt der spannendste Abschnitt!

Anfänglich werden die Transaktionen in einer Liste nicht verifizierter Transaktionen geführt. Mining bezieht sich auf den Prozess, die ungeprüften Transaktionen in einen Block zu legen und das PoW-Problem zu lösen. Es kann als die Rechenarbeit bezeichnet werden, die bei der Überprüfung der Transaktionen beteiligt ist.

Wenn alles richtig herausgefunden wurde, wird ein Block erstellt oder abgebaut und mit den anderen in der Blockchain zusammengefügt. Wenn Benutzer einen Block erfolgreich abgebaut haben, werden sie oft dafür belohnt, dass sie ihre Computerressourcen zur Lösung des PoW-Problems verwenden.

Hier ist die Mining-Methode in diesem einfachen Kryptowährungs-Blockchain-Projekt:

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)

Zusammenfassung

Hier ist der gesamte Code für unsere Krypto-Blockchain-Klasse in 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)

Lassen Sie uns nun versuchen, unseren Code auszuführen, um zu sehen, ob wir einige digitale Münzen generieren können ...

Wow, es hat funktioniert!

Abschluss

Das ist es!

Wir hoffen, dass dieser Artikel Ihnen geholfen hat, die zugrunde liegende Technologie zu verstehen, die Kryptowährungen wie Bitcoin und Ethereum antreibt.

Wir haben gerade die Grundideen veranschaulicht, um Ihre Füße in der innovativen Blockchain-Technologie nass zu machen. Das obige Projekt kann noch verbessert werden, indem andere Funktionen integriert werden, um es nützlicher und robuster zu machen.