La publicación Creación de una aplicación blockchain con C++ apareció primero en Coinpedia Fintech News
Introducción
La tecnología blockchain ha transformado fundamentalmente las finanzas y la gestión de la cadena de suministro al ofrecer mecanismos descentralizados, transparentes y seguros que eliminan la necesidad de intermediarios.
¿Por qué debería uno crear una aplicación blockchain?
Las aplicaciones de blockchain brindan una mayor integridad y seguridad de los datos y brindan un entorno confiable para compartir información. Con blockchain, se pueden implementar contratos inteligentes y crear tokens digitales que abren las puertas a nuevos modelos económicos como las finanzas descentralizadas (DeFi) y los activos tokenizados, etc.
Este artículo es un recorrido rápido de 10 minutos por el mundo del desarrollo de Blockchain a través de C++.
Conceptos básicos de blockchain
Blockchain es una cadena digital formada por unidades individuales seguras y a prueba de manipulaciones llamadas bloques. Cada bloque contiene sus metadatos y la información designada de la transacción. Hasta ahora, solo hemos creado bloques individuales, ¿no? ¿Cómo intentarías establecer una conexión entre cada bloque de manera significativa? La respuesta es vinculando cada bloque con su bloque anterior con la ayuda de funciones criptográficas aleatorias únicas conocidas como hash. Cada bloque tiene su propio hash, que es una clave principal y puedes vincular todos los bloques a través del hash en orden cronológico, formando una cadena que representa todo el historial de transacciones dentro de la red.
C++ en la cadena de bloques
C++ es uno de los lenguajes más potentes que se utilizan en blockchain debido a su velocidad, flexibilidad y control. Funciona de maravillas al manejar sistemas complejos, desarrollo de juegos y aplicaciones financieras. ¡Sin duda es el lenguaje más versátil!
C++ destaca en el ámbito de la cadena de bloques por múltiples razones. Permite a los desarrolladores crear sistemas de cadena de bloques eficientes gracias a su gestión de memoria de bajo nivel que proporciona un control preciso. Todos sabemos lo enorme y segura que es la red Bitcoin. Imaginemos lo complejo que debe ser su núcleo, ya que necesita gestionar innumerables transacciones. Por lo tanto, para gestionar esta abrumadora tarea, se eligió C++. Hay algunas aplicaciones importantes desarrolladas con C++, como Bitcoin, Lifecoin, Ripple, Monero y EOS.
¿Por qué C++ es un lenguaje ideal para el desarrollo de blockchain?
Cálculos más rápidos
Alto rendimiento
Gestión eficiente de la memoria
Características orientadas a objetos
Admite subprocesos múltiples
Control sobre los recursos del sistema
Ya sea que sea nuevo en blockchain o que desee superar los límites de lo posible, C++ es una opción sólida para crear aplicaciones duraderas.
Comprender los conceptos de blockchain con C++
Transacciones: En la cadena de bloques, las transacciones son la esencia que impulsa todo el sistema. Los bloques individuales son como bóvedas seguras que guardan la información prestigiosa de intercambio y valor de las transacciones junto con los participantes. Estas transacciones son los registros fundamentales que cuentan la historia de quién intercambió qué, con quién y cuándo.
Pilares de Blockchain que debes conocer
Descentralización: La descentralización es la razón por la que blockchain se destaca en todo el dominio tecnológico. ¿Qué es la descentralización? Es una propiedad de blockchain por la cual ninguna entidad individual tiene control sobre toda la base de datos. Esto hace que el sistema sea robusto a fallas e inhibe cualquier tipo de sesgo. Cada dispositivo participante (nodo) mantiene una copia de la blockchain, lo que garantiza la transparencia y evita fallas o manipulaciones centralizadas.
Inmutabilidad: una vez que escribes datos en la cadena de bloques, no puedes modificarlos sin cambiar los bloques posteriores. Esto se hace con la ayuda del hash criptográfico. Por lo tanto, todos los cambios realizados una vez no se pueden deshacer, lo que los hace inmutables.
Mecanismos de consenso: Un conjunto de protocolos que rigen todas las necesidades de la cadena de bloques. Todos los nodos de la red deben ponerse de acuerdo sobre los métodos. Los mecanismos de consenso se utilizan para agilizar los nodos y garantizar que todos los nodos de la red estén en la misma página.
Hasta ahora debes haber entendido todos los conceptos básicos de blockchain, ¿verdad? ¡Basta de teoría! Pasemos ahora a la parte práctica. ¿Estás listo para ponerte manos a la obra?
En esta sección, lo guiaremos a través de todo el proceso de desarrollo de una aplicación blockchain simple, desde la configuración del entorno hasta las pruebas y la implementación.
1. Configuración del entorno de desarrollo de C++
Antes de comenzar con el desarrollo, es fundamental contar con todos los requisitos previos. En este capítulo, veremos cómo contar con el entorno de desarrollo adecuado.
Instalación del compilador de C++
Comencemos por entender qué es un compilador.
Un compilador es una herramienta crucial en el desarrollo de software, que actúa como un puente entre el código legible por humanos que escribes y el código de máquina que el procesador de tu computadora puede entender y ejecutar. En el contexto del desarrollo de aplicaciones de blockchain en C++, el primer paso es equiparte con un compilador de C++ confiable. Esta herramienta traducirá tu código C++ en código de máquina ejecutable, lo que permitirá que tu aplicación de blockchain se ejecute de manera eficiente en varios sistemas.
Por lo tanto, para comenzar el desarrollo, primero instale el compilador de C++ compatible con su sistema. A continuación, se muestran los compiladores de C++ más populares entre los que puede elegir:
GCC (colección de compiladores GNU):
Linux/MacOS:
Abra la terminal y escriba los comandos que se indican a continuación respectivamente
a) Ubuntu/Debian: sudo apt updatesudo apt install build-essential b) Fedora sudo dnf install gcc gcc-c++ c) MacOS (herramientas de línea de comandos) xcode-select –install
Windows: para los usuarios de Windows, el proyecto MinGW-w64 es una excelente opción ya que proporciona un puerto Windows de GCC (GNU Compiler Collection), ofreciendo la potencia de GCC dentro de un entorno Windows.
Pasos para la instalación:
Descargue el instalador visitando el sitio web oficial de MinGW-w64.
Ejecute el instalador después de la descarga
Seleccione la arquitectura adecuada según sus necesidades.
Siga los pasos del asistente para completarlo.
Actualice el sistema (este es un paso opcional pero recomendado).
Sonido metálico:
Linux/MacOS: sudo apt install clang (también clang ya está instalado en MacOS) Fedora: sudo dnf install clang Windows: Clang se puede instalar usando MinGW o a través del instalador del proyecto LLVM
MSVC (Microsoft Visual C++):
MSVC (Microsoft Visual C++) es un componente integral de Visual Studio, un sólido entorno de desarrollo integrado (IDE) desarrollado por Microsoft. Visual Studio ofrece un conjunto completo de herramientas para desarrollar, probar e implementar aplicaciones, y al instalarlo se configurará automáticamente MSVC en el sistema.
Verifique la instalación utilizando los siguientes comandos en la terminal o el símbolo del sistema:
g++ –version # Para GCCclang –version # Para Clangcl # Para MSVC
Elección de un IDE
Un entorno de desarrollo integrado (IDE) aumenta la productividad al ofrecer herramientas como finalización de código, depuración y gestión de proyectos dentro de una interfaz unificada. A continuación, se muestran algunos IDE de uso generalizado para el desarrollo en C++:
Visual Studio: Descargue Visual Studio desde el sitio web oficial.
Y siga los siguientes pasos como se menciona en la siguiente tabla:
CLion: Instalación y configuración:
CLion es un IDE popular y funciona con JetBrains, pero requiere una suscripción y ofrece pruebas gratuitas.
ofrece pruebas gratuitas
Visual Studio Code: instalar y configurar extensiones para el desarrollo de C++.
Instalación de las bibliotecas necesarias
Utilice administradores de paquetes para instalar bibliotecas esenciales como OpenSSL para funciones criptográficas. A continuación se muestran los pasos y las distintas bibliotecas para diferentes sistemas operativos y sus comandos.
¡Genial! Has configurado exitosamente tu entorno de desarrollo y puedes comenzar a ejecutar el código directamente en el IDE que elijas.
2. Construyendo una cadena de bloques simple con C++
Antes de comenzar a escribir el código, comprendamos los componentes de una clase de bloque.
Componentes de Blockclass
Un índice es un número entero que almacena y mantiene el orden ordenado de los bloques cronológicamente.
Marca de tiempo: la marca de tiempo almacena la instancia en la que se creó el bloque en forma de cadena.
Transacciones: Las transacciones almacenan la información del intercambio entre los participantes y el estado de la cadena de bloques en ese momento.
Hash anterior y Hash: El hash anterior almacena el hash criptográfico del bloque anterior mientras que el hash es una cadena de información criptográfica desordenada o hash.
Nonce: un número entero utilizado en el algoritmo de consenso de prueba de trabajo (PoW). Actúa como un contador que se incrementa para encontrar un hash válido que cumpla con el objetivo de dificultad. El nonce es crucial para el proceso de minería en PoW, donde los mineros compiten para encontrar un nonce que genere un hash con una cantidad específica de ceros iniciales.
Implementemos todas las funciones en el código ahora:
clase Bloque {público: int índice; std::string marca de tiempo; std::vector<Transacción> transacciones; std::string hash anterior; std::string hash; int nonce; // Para PoW // Constructor Bloque(int idx, std::string tiempo, std::vector<Transacción> txs, std::string prevHash) { índice = idx; marca de tiempo = tiempo; transacciones = txs; previousHash = prevHash; nonce = 0; hash = calculateHash(); // Hash del bloque actual } // Método para calcular el hash del bloque std::string calculateHash() { std::stringstream ss; ss << index << timestamp << previousHash << nonce; // Agrega datos de transacción y cualquier detalle adicional al cálculo de hash return sha256(ss.str()); // Marcador de posición para la función hash real } // Método para minar el bloque void mineBlock(int difficulty) { std::string target(difficulty, ‘0’); // Crea una cadena de hash de destino while (hash.substr(0, difficulty) != target) { nonce++; hash = calculateHash(); } }};
Una vez que hayas terminado de definir la clase de bloque y sus atributos, puedes continuar y crear el bloque génesis. El bloque génesis es el primer bloque en la cadena de bloques que debe inicializarse y tiene un índice de cero. Después de definir el bloque génesis, puedes continuar y agregar nuevos bloques a tu cadena de bloques usando el método addblock(). A continuación, puedes encontrar el código:
clase Blockchain {público: std::vector<Block> cadena; Blockchain() { cadena.push_back(createGenesisBlock()); } Bloque createGenesisBlock() { devolver Bloque(0, “01/01/2024”, “Bloque Génesis”, “0”); } Bloque getLatestBlock() { devolver cadena.back(); } void addBlock(Bloque nuevoBloque) { nuevoBloque.previousHash = getLatestBlock().hash; nuevoBloque.hash = nuevoBloque.calculateHash(); cadena.push_back(nuevoBloque); }};
Crea y verifica la transacción. Cada transacción tiene su propia ID, un constructor predefinido y la información del remitente y del destinatario junto con el monto. Después de crear una transacción, debes verificarla utilizando el método validationTransaction().
clase Transacción {público: std::string remitente; std::string destinatario; doble importe; std::string IDtransacción; // Constructor Transacción(std::string snd, std::string rcp, doble importe, std::string txID) { remitente = snd; destinatario = rcp; importe = importe; IDtransacción = txID; } // Método para validar la transacción bool validationTransaction() { // Implementación de la lógica de validación return true; // Marcador de posición }};
3. Implementación de mecanismos de consenso en C++
Hasta ahora, has completado el 25 % del proceso de creación. Ahora, avanza e implementa los mecanismos de consenso para tu bloque, que es la columna vertebral de toda la aplicación.
Prueba de trabajo
La Prueba de Trabajo (PoW) es un mecanismo de consenso mediante el cual los miembros de la red blockchain/mineros deben encontrar una solución a un problema matemático computacional difícil antes de poder agregar un nuevo bloque a la cadena. Esto es esencialmente un proceso de encontrar un número específico, llamado nonce, que se combina con los datos del bloque, su hash y otros detalles para generar un valor hash que comienza con una cierta cantidad de ceros iniciales. Esto hace que el proceso sea eficiente y protege la red de ataques maliciosos.
En C++, puedes implementar la prueba de trabajo agregando un atributo proof y un método proof of work a la clase Block. Aquí te mostramos cómo hacerlo:
#include <iostream>#include <sstream>#include <ctime>#include <string>#include <vector>#include <openssl/sha.h>using namespace std;string sha256(const string str) { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, str.c_str(), str.length()); SHA256_Final(hash, &sha256); stringstream ss; para(int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } devolver ss.str();}clase Bloque {público: int índice; cadena datos; cadena previousHash; cadena hash; prueba larga; tiempo_t marca de tiempo; Bloque(int idx, cadena d, cadena prevHash) { índice = idx; datos = d; previousHash = prevHash; marca de tiempo = tiempo(nullptr); prueba = 0; hash = calculateHash(); } string calculateHash() const { stringstream ss; ss << índice << marca de tiempo << datos << previousHash << prueba; return sha256(ss.str()); } void proofOfWork(int dificultad) { string objetivo(dificultad, ‘0’); hacer { prueba++; hash = calculateHash(); } mientras (hash.substr(0, dificultad) != objetivo); }};clase Blockchain {público: vector<Block> cadena; int dificultad; Blockchain(int diff) { dificultad = diff; cadena.emplace_back(Bloque(0, “Bloque Génesis”, “0”)); } void addBlock(string datos) { Bloque newBlock(cadena.size(), datos, cadena.back().hash); newBlock.proofOfWork(dificultad); if (isValidProof(newBlock)) { cadena.push_back(newBlock); } } bool isValidProof(const Bloque& bloque) const { return bloque.hash.substr(0, dificultad) == string(dificultad, ‘0’); }};
En el fragmento de código anterior, podemos ver que primero debemos agregar una prueba y un hash al bloque. Luego, decidir la dificultad de la prueba y extraerla. Después de esto, puedes validar la prueba.
4. Creación de una API de cadena de bloques sencilla con C++
API: la interfaz de programación de aplicaciones es una herramienta que permite que diferentes aplicaciones de software interactúen entre sí. En blockchain, las API facilitan la interacción con los datos de blockchain predefinidos, por lo que los desarrolladores pueden crear rápidamente las aplicaciones sin necesidad de conocer toda la estructura subyacente de la red. Las API ayudan a integrar blockchain con otras plataformas, como aplicaciones web o móviles. Por lo tanto, las API son necesarias para permitir un desarrollo e integración eficientes.
Configuración del entorno API
Instalar y configurar las herramientas necesarias para crear API con C++ como se menciona en la siguiente tabla:
Construyendo la API
#include <cpprest/http_listener.h>#include <cpprest/json.h>#include “blockchain.h”using namespace web;using namespace http;using namespace utility;using namespace http::experimental::listener;Blockchain blockchain(4); // nivel de dificultad 4void handleGet(http_request request) { json::value respuesta = json::value::array(); int i = 0; para (auto& block : blockchain.chain) { json::value block_json; block_json[U(“índice”)] = json::value::número(block.índice); block_json[U(“datos”)] = json::valor::cadena(bloque.datos); block_json[U(“Hashanterior”)] = json::valor::cadena(bloque.Hashanterior); block_json[U(“hash”)] = json::valor::cadena(bloque.hash); block_json[U(“prueba”)] = json::valor::número(bloque.prueba); block_json[U(“marca de tiempo”)] = json::valor::número(bloque.marca de tiempo); respuesta[i++] = block_json; } solicitud.respuesta(códigos_estado::OK, respuesta);}void handlePost(solicitud http_request) { solicitud.extraer_json().then([&](json::value requestData) { auto datos = requestData[U(“datos”)].as_string();blockchain.addBlock(datos);solicitud.respuesta(códigos_estado::OK, U(“Bloque agregado exitosamente”));}).wait();}int main() {escucha http_listener escucha(U(“http://localhost:8080”));escucha.soporte(métodos::GET, handleGet);escucha.soporte(métodos::POST, handlePost);try {escucha.open().wait();cout << “Escuchando en http://localhost:8080” << endl; mientras (verdadero);} catch (excepción const& e) {cerr << e.what() << endl; }return 0;}
handleGet recupera la cadena de bloques completa en formato JSON.
handlePost agrega un nuevo bloque a la cadena de bloques utilizando los datos de la solicitud POST.
Ejecución y prueba de la aplicación
Ejecutar la aplicación
Una vez que haya terminado con las funciones básicas del código según el ciclo de desarrollo de software, debe pasar al paso más crucial e inevitable de compilar y probar toda la aplicación. Esto es muy importante para confirmar que los componentes de la aplicación se ejecutan como se espera.
Compila el código: g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprestEjecuta el ejecutable: ./blockchain_api
El código anterior inicia el servidor API en http://localhost:8080.
Pruebas con Postman
Pruebe los puntos finales de la API usando Postman o curl:
Agregar un bloque:
Método: POST
URL: http://localhost:8080
Cuerpo: formato JSON
{ “data”: “Este es un nuevo bloque”}
Ver Blockchain:
Método: GET
URL: http://localhost:8080
Ejemplo de cómo agregar un bloque y visualizar la cadena de bloques usando la API creada con C++.
void handleGet(http_request request) { json::valor respuesta = json::valor::matriz(); int i = 0; para (auto& bloque : blockchain.chain) { json::valor bloque_json; bloque_json[U(“índice”)] = json::valor::número(bloque.índice); bloque_json[U(“datos”)] = json::valor::cadena(bloque.datos); block_json[U(“previousHash”)] = json::valor::cadena(bloque.previousHash); block_json[U(“hash”)] = json::valor::cadena(bloque.hash); block_json[U(“prueba”)] = json::valor::número(bloque.prueba); block_json[U(“marca de tiempo”)] = json::valor::número(bloque.marca de tiempo); respuesta[i++] = block_json; } solicitud.respuesta(códigos_de_estado::OK, respuesta); }void handlePost(http_request request) { request.extract_json().then([&](json::value requestData) { auto data = requestData[U(“datos”)].as_string();blockchain.addBlock(datos);request.reply(status_codes::OK, U(“Bloque agregado exitosamente”)) }).wait();}
La función handlePost procesa la adición de bloques extrayendo datos del cuerpo JSON y agregando un nuevo bloque a la cadena de bloques.
La función handleGet recupera la cadena de bloques completa y la envía como una respuesta JSON.
6. Ejemplo en vivo de creación de una aplicación blockchain con C++
Ejecución paso a paso
Paso 1: Cree la clase Block con los atributos necesarios utilizando la sintaxis C++.
#include <iostream>#include <ctime>#include <string>#include <sstream>#include <vector>#include <openssl/sha.h>using namespace std;clase Bloque {público: int índice; cadena datos; cadena previousHash; cadena hash; prueba larga; time_t marca de tiempo; Bloque(int idx, constante string& datos, constante string& prevHash) : índice(idx), datos(datos), previousHash(prevHash), prueba(0), marca de tiempo(tiempo(nullptr)) { hash = calculateHash(); } string calculateHash() const { stringstream ss; ss << índice << marca de tiempo << datos << previousHash << prueba; return sha256(ss.str()); } void proofOfWork(int dificultad) { string objetivo(dificultad, ‘0’); do { prueba++; hash = calculateHash(); } while (hash.substr(0, dificultad) != objetivo); }private: string sha256(const string& entrada) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, entrada.c_str(), entrada.size()); SHA256_Final(hash, &sha256); stringstream ss; para (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } devolver ss.str(); }};
Paso 2: Implemente el método calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>clase Bloquear {público: int índice; std::string datos; std::string previousHash; std::string hash; prueba larga; time_t marca de tiempo; Bloque(int idx, const std::string& datos, const std::string& prevHash) : índice(idx), datos(datos), previousHash(prevHash), prueba(0), marca de tiempo(tiempo(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << índice << marca de tiempo << datos << previousHash << prueba; return sha256(ss.str()); }private: std::string sha256(const std::string& entrada) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, entrada.c_str(), entrada.size()); SHA256_Final(hash, &sha256); std::stringstream ss; para (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } devolver ss.str(); }};
Paso 3: Definir la clase Blockchain e inicializarla con un bloque de génesis.
clase Blockchain {público: Blockchain(int dificultad) : dificultad(dificultad) { cadena.emplace_back(Bloque(0, “Bloque Génesis”, “0”)); } void addBlock(const string& data) { Bloque newBlock(cadena.size(), data, cadena.back().hash); newBlock.proofOfWork(dificultad); cadena.push_back(newBlock); } const Block& latestBlock() const { return cadena.back(); } vector<Block> cadena;private: int dificultad;};
Paso 4: Implementar el método calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>clase Bloquear {público: int índice; std::string datos; std::string previousHash; std::string hash; prueba larga; time_t marca de tiempo; Bloque(int idx, const std::string& datos, const std::string& prevHash) : índice(idx), datos(datos), previousHash(prevHash), prueba(0), marca de tiempo(tiempo(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << índice << marca de tiempo << datos << previousHash << prueba; return sha256(ss.str()); }private: std::string sha256(const std::string& entrada) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, entrada.c_str(), entrada.size()); SHA256_Final(hash, &sha256); std::stringstream ss; para (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } devolver ss.str(); }};
Paso 5: Definir la clase Blockchain e inicializarla con un bloque de génesis.
clase Blockchain {público: Blockchain(int dificultad) : dificultad(dificultad) { cadena.emplace_back(Bloque(0, “Bloque Génesis”, “0”)); } void addBlock(const string& data) { Bloque newBlock(cadena.size(), data, cadena.back().hash); newBlock.proofOfWork(dificultad); cadena.push_back(newBlock); } const Block& latestBlock() const { return cadena.back(); } vector<Block> cadena;private: int dificultad;};
Paso 6: Configure el entorno de API para manejar solicitudes utilizando una biblioteca C++ adecuada.
#include <cpprest/http_listener.h>#include <cpprest/json.h>usando el espacio de nombres web;usando el espacio de nombres web::http;usando el espacio de nombres web::http::experimental::listener;clase BlockchainAPI {público: BlockchainAPI(const string& dirección, Blockchain& blockchain) : listener(http_listener(U(dirección))), blockchain(blockchain) { listener.support(métodos::GET, std::bind(&BlockchainAPI::handleGet, this, std::placeholders::_1));listener.support(métodos::POST, std::bind(&BlockchainAPI::handlePost, this, std::placeholders::_1));void start() {listener.open().wait(); cout << “API de blockchain ejecutándose…” << endl; }Privado:http_listener listener; Blockchain& blockchain;void handleGet(http_request request) {json::value respuesta = json::value::array();int i = 0;for (const auto& block : blockchain.chain) {json::value block_json;block_json[U(“índice”)] = json::value::número(bloque.índice);block_json[U(“datos”)] = json::value::cadena(bloque.datos);block_json[U(“Hash previo”)] = json::value::cadena(bloque.Hash previo);block_json[U(“hash”)] = json::value::cadena(bloque.hash);block_json[U(“prueba”)] = json::value::número(bloque.prueba);block_json[U(“marca de tiempo”)] = json::value::número(bloque.marca de tiempo);respuesta[i++] = block_json; } solicitud.respuesta(códigos_estado::OK, respuesta); }void handlePost(http_request solicitud) {solicitud.extraer_json().then([&](json::value requestData) {cadena datos = requestData[U(“datos”)].as_string();blockchain.addBlock(datos);solicitud.respuesta(códigos_estado::OK, U(“Bloque agregado exitosamente”));}) .wait () ; }} ;
Paso 7: Pruebe la aplicación extrayendo un nuevo bloque y verificando la cadena de bloques utilizando Postman o curl.
Principal:int main() { Blockchain blockchain(4); // Nivel de dificultad BlockchainAPI api(“http://localhost:8080”, blockchain); api.start(); return 0;}Prueba:curl -X POST http://localhost:8080 -H “Content-Type: application/json” -d ‘{“data”:”Este es un nuevo bloque”}’
Emprender el desarrollo de blockchain con C++ es más que solo codificar; se trata de construir los elementos fundamentales de sistemas descentralizados que tienen el potencial de revolucionar diversas industrias.
En resumen, hemos cubierto todo, desde los conceptos básicos de la programación C++ para blockchain hasta la implementación y prueba de la aplicación.
Una vez que haya completado este módulo, podrá explorar más a fondo los conceptos de optimización como escalabilidad, prácticas de seguridad, mecanismos de consenso avanzados y contratos inteligentes.
Mantén la curiosidad, adopta el aprendizaje continuo y sigue codificando. ¡Que tus contribuciones impulsen el futuro de la tecnología!