Hyperledger

Hyperledger

Circulor, working with the government of Rwanda and Power Resources Group, has launched the first production ready system to trace a conflict mineral, Tantalum, from mine to manufacturer. It’s an incredible use case with massive social impact.

Maticjs Web3: Web3.js Plugin for Matic.js

maticjs-web3

web3.js plugin for matic.js

Installation

npm i @maticnetwork/maticjs-web3

Examples

All the examples are in the examples folder.

Docs


import { use } from '@maticnetwork/maticjs'
import { Web3ClientPlugin } from '@maticnetwork/maticjs-web3'

// install ethers plugin
use(Web3ClientPlugin)

That's all you need to do and web3.js will be used for web3 calls.

Download Details:
Author: maticnetwork
Source Code: https://github.com/maticnetwork/maticjs-web3
License: MIT license

#polygon #web3  #hyperledger  #smartcontract #typescript #javascript 

Maticjs Web3: Web3.js Plugin for Matic.js
高橋  花子

高橋 花子

1652850540

CouchDBとLevelDB:状態データベースオプションの比較

Hyperledger Fabricは、エンタープライズブロックチェーンソリューションおよびアプリケーションの開発に使用される、オープンソースの許可されたブロックチェーンフレームワークです。Hyperledger Fabricプロジェクトは、Hyperledger内の主要なブロックチェーンプロジェクトの1つであり、業界を超えたブロックチェーンテクノロジーを進歩させるためにLinuxFoundationによって2015年に開始されたマルチプロジェクトの共同作業です。現在、Hyperledger Fabricには、120,000を超える貢献組織、15,000を超えるエンジニアの貢献者が協力してプロジェクトを推進しています。

Hyperledger Fabricはモジュラー(プラグアンドプレイ)アーキテクチャを備えており、毎秒1,000トランザクション(TPS)を超えるトランザクションに到達でき、20,000TPSにアップグレードできます。Hyperledger Fabricは、他のブロックチェーンテクノロジーとは異なり、企業による採用を容易にする特定の機能セットも提供します。これらの機能は次のとおりです。

Hyperledger Fabricは多くの実装が行われており、銀行や金融、国際貿易、モノのインターネットなどの業界で広く使用されています。Hyperledger Fabricは、承認者、コミッター、データベースなど、多くのコンポーネントで構成されています。

HyperledgerFabricネットワークで対話するためのオプション

Hyperledger Fabricネットワークで対話するには、チェーンコード(スマートコントラクトとも呼ばれます)が使用されます。これらのスマートコントラクトは、Go、Node.js、Javaなどのさまざまなプログラミング言語で記述できます。

Hyperledger Fabricは、チェーンコードによって実行されたトランザクションの状態をデータベースに保存します。HyperledgerFabricネットワークによって保存されるレコードには主に2つのタイプがあります。

  • トランザクションログ:これは、Hyperledger Fabricネットワークのブロックチェーンの側面であり、HyperledgerFabricネットワークの現在の状態をもたらしたすべてのトランザクションの記録で構成されます。トランザクションログに保存されるデータは不変であり、LevelDBデータベースに保存されます
  • 世界の状態:これは、特定の時点での元帳の現在の値です。デフォルトでは、FabricネットワークのメインデータベースはLevelDBデータベースであり、特定のトランザクションが完了したときにのみデータが入力されます。ただし、CouchDBデータベースに置き換えることができます

この記事では、CouchDBデータベースとLevelDBデータベースのどちらをワールドステートデータベースとして選択するかについて説明します。

楽しみ!

PostgreSQLやMySQLのようなデータベースを使ってみませんか?

Hyperledger Fabricは、LevelDBとCouchDBのみをサポートし、PostgreSQL、MongoDB、MySQLなどのデータベースはサポートしません。このHyperledgerフォーラムでの議論では、プラグ可能なデータベースのサポートを提供するには、ネットワークとデータベース自体に多くの変更を加える必要があると述べています。プロジェクトは、当面の間、Hyperledgerの開発パイプラインから削除されました。

ただし、状態データベースとしてPostgreSQLなどのデータベースを設定する方法はまだあります。これらの手順に従うことで、Fabricプロジェクトをフォークし、 PostgreSQL、MySQL、MongoDBなどのデータベースをプラグインできます。このIBMの例は、HyperledgerFabricプロジェクトでPostgreSQLをセットアップするために使用できる方法も示しています。

LevelDBとは何ですか?

LevelDBデータベースは、キーと値のペアを格納できる高速データベースです。LevelDBデータベースはSanjayGhemawatとJeffDeanによってGoogleで作成され、現在HyperledgerFabricがトランザクションログを保存するために使用している唯一のデータベースです。前述のように、これはHyperledgerFabricにワールド状態を格納するために使用されるデフォルトのデータベースでもあります。

LevelDBのキーと値のペアは、任意のバイト配列に格納されます。LevelDBは、、、および複合キークエリ、つまりKey、、、およびのみをサポートします。Key rangePut(key, value)GET(key, value)Delete(key)

LevelDBはSQLデータベースではないため、SQLクエリ、インデックス、またはリレーショナルデータモデルはサポートされていません。

LevelDBの利点

  • LevelDBは、CouchDBと比較してオーバーヘッドが少ない、シンプルで高速なデータベースです。
  • データは保存され、キーでマッピングされます
    • 、、、などPut(key, value)の単純な操作を実行できるため、LevelDBの使用が簡単になります。GET(Key, Value)Delete(Key)
  • LevelDBは、データ、スナップショット、およびアトミックバッチでの変更に対する順方向および逆方向の反復をサポートします

LevelDBの制限

  • インデックスとクエリはサポートされていません
  • Put(key, value)、、GET(key, value)やDelete(key)などの単純な操作のみが可能です。
  • SQLデータベースではないため、リレーショナルデータモデルの使い慣れた機能はありません。データはキーと値のペアでのみ保存できます
  • LevelDBデータベースからの大規模なデータセットのクエリは、複雑なクエリとインデックスが許可されていないため、非効率的で複雑です。

CouchDBとは何ですか?

CouchDBデータベースは、Erlangに実装されたオープンソースのドキュメント指向データベースであり、JSON形式でデータを収集して保存します。Hyperledger Fabricユーザーは、デフォルトのLevelDBワールドステートデータベースをCouchDBデータベースに置き換えることができます。これは、利用可能な唯一の代替手段でもあります。

CouchDBは、保存されたJSONコンテンツの豊富なクエリを可能にするNoSQLデータベースです。CouchDBデータベースのデフォルトのクエリ言語はJavaScriptであり、データはJSON形式でスキーマを設定せずに保存できます。

CouchDBはインデックスとページネーションをサポートしています。LevelDBデータベースと同様に、キーに基づいてクエリを実行することもできます。

CouchDBの利点

  • CouchDBではJSONクエリとインデックスが可能であるため、LevelDBよりもHyperledgerFabricネットワークの監査とレポートの要件を満たすことが容易になります。
  • ドキュメント指向データベースとして、CouchDBを使用すると、データを配列または辞書としてデータベースに保存できます。
  • CouchDBデータはHTTPURIを介して公開されます。これにより、データに対してHTTP操作(、、、)を実行できるようにGETなりますDELETEPUTPOST
  • CouchDBを使用すると、チェーンコードの大規模なデータセットをインデックスでより効率的かつ柔軟にクエリできます。

CouchDBの制限

  • CouchDBは、HyperledgerFabricネットワークと並行して別個のデータベースとして実行されます
  • ネットワークを実行するには、データベースの管理、セットアップ、構成などの面で、より多くのコミットメントが必要です。

次のHyperledgerFabricプロジェクトの状態データベースを選択する

状態データベースを選択する前に、Hyperledger Fabricは、Hyperledger Fabricネットワークの起動後にデータベースを変更できないため、データベースを決定する必要があることを知っておく必要があります。

トランザクションの量が少ない単純なHyperledgerFabricプロジェクトを実行している場合、LevelDBの使いやすさと速度により、使用するのが非常に望ましいです。

ただし、より複雑なプロジェクトの場合は、CouchDBデータベースを使用することをお勧めします。CouchDBは、キーに基づいてデータを取得および設定するなど、LevelDBデータベースのすべての機能を備えていますが、JSON形式でのデータの保存、インデックス、クエリの発行、ページネーションなどの追加機能へのアクセスも提供します。データの操作が簡単になります。

CouchDBが提供する機能により、大量のトランザクションを伴うHyperledgerFabricネットワークの管理が容易になります。CouchDBを使用すると、HyperledgerFabricネットワークを実行している最新の組織で必要とされる監査とレポートの要件を簡単に完了することができます。

結論

この記事では、Hyperledger Fabric、CouchDB、およびLevelDBで使用可能なワールドステートデータベースオプションについて説明しました。各データベースの利点と制限について説明し、次のHyperledgerFabricプロジェクト用にデータベースを選択する方法について説明しました。

ソース:https ://blog.logrocket.com/couchdb-vs-leveldb-comparing-state-database-options/ 

#leveldb #couchdb #hyperledger #fabric 

CouchDBとLevelDB:状態データベースオプションの比較
Saul  Alaniz

Saul Alaniz

1652850480

CouchDB Vs. LevelDB: Comparación De Las Opciones De La Base De Datos

Hyperledger Fabric es un marco de cadena de bloques autorizado de código abierto que se utiliza para desarrollar soluciones y aplicaciones de cadenas de bloques empresariales. El proyecto Hyperledger Fabric es uno de los principales proyectos de cadena de bloques dentro de Hyperledger , un esfuerzo de colaboración de varios proyectos iniciado en 2015 por la Fundación Linux para avanzar en las tecnologías de cadena de bloques entre industrias. Actualmente, Hyperledger Fabric cuenta con más de 120 000 organizaciones contribuyentes y más de 15 000 ingenieros contribuyentes que trabajan juntos para avanzar en el proyecto.

Hyperledger Fabric tiene una arquitectura modular (plug-and-play) y puede alcanzar transacciones de más de 1000 transacciones por segundo (TPS), que se pueden actualizar para llegar a 20 000 TPS . Hyperledger Fabric también proporciona un conjunto particular de características que lo diferencia de otras tecnologías de cadena de bloques y permite una adopción más fácil por parte de las empresas. Estas características son:

Hyperledger Fabric ha visto mucha implementación y se usa ampliamente en industrias como la banca y las finanzas, el comercio internacional y el Internet de las cosas. Hyperledger Fabric consta de muchos componentes, como patrocinadores, confirmadores y bases de datos.

Opciones para interactuar en una red Hyperledger Fabric

Para interactuar en una red de Hyperledger Fabric, se utilizan códigos de cadena (también conocidos como contratos inteligentes). Estos contratos inteligentes se pueden escribir en diferentes lenguajes de programación, incluidos Go, Node.js y Java.

Hyperledger Fabric almacena el estado de las transacciones realizadas por códigos de cadena en bases de datos. Hay dos tipos principales de registros almacenados por una red Hyperledger Fabric:

  • Registros de transacciones : este es el aspecto blockchain de la red Hyperledger Fabric, que comprende un registro de todas las transacciones que dieron como resultado el estado actual de la red Hyperledger Fabric. Los datos almacenados en el registro de transacciones son inmutables y se almacenan en una base de datos LevelDB
  • Estado mundial : este es el valor actual del libro mayor en un momento dado. La base de datos principal de la red Fabric, de manera predeterminada, es una base de datos LevelDB y solo se completa cuando se completa una transacción determinada; sin embargo, se puede reemplazar con una base de datos Couch DB

En este artículo, vamos a discutir cómo elegir entre las bases de datos CouchDB y LevelDB como su base de datos de estado mundial.

¡Disfrutar!

¿Por qué no usar una base de datos como PostgreSQL o MySQL?

Hyperledger Fabric solo brinda soporte para LevelDB y CouchDB y no brinda soporte para bases de datos como PostgreSQL, MongoDB o MySQL. Una discusión en este foro de Hyperledger establece que, para brindar soporte para bases de datos conectables, se deben realizar muchos cambios en la red y la base de datos. El proyecto ha sido eliminado de la tubería de desarrollo de Hyperledger por el momento.

Sin embargo, todavía hay formas de configurar una base de datos como PostgreSQL como su base de datos estatal. Puede bifurcar el proyecto Fabric y conectar una base de datos como PostgreSQL, MySQL o MongoDB siguiendo estas instrucciones. Este ejemplo de IBM también muestra un método que puede usar para configurar PostgreSQL en su proyecto Hyperledger Fabric.

¿Qué es LevelDB?

La base de datos LevelDB es una base de datos rápida que le permite almacenar pares clave-valor. La base de datos LevelDB fue escrita en Google por Sanjay Ghemawat y Jeff Dean, y actualmente es la única base de datos utilizada por Hyperledger Fabric para almacenar registros de transacciones. Como se mencionó anteriormente, también es la base de datos predeterminada utilizada para almacenar el estado mundial en Hyperledger Fabric.

Los pares clave-valor de LevelDB se almacenan en matrices de bytes arbitrarias. LevelDB proporciona soporte solo para Key, Key rangey consultas de clave compuesta, es decir, Put(key, value), GET(key, value)y Delete(key).

No hay soporte para consultas SQL, índices o modelos de datos relacionales, ya que LevelDB no es una base de datos SQL.

Ventajas de LevelDB

  • LevelDB es una base de datos simple y rápida con menos gastos generales en comparación con CouchDB
  • Los datos se almacenan y mapean con claves
    • Puede realizar operaciones simples, como Put(key, value), GET(Key, Value)y Delete(Key), lo que hace que LevelDB sea menos complejo de usar
  • LevelDB admite iteraciones hacia adelante y hacia atrás sobre los datos, instantáneas y cambios en lotes atómicos

Limitaciones de LevelDB

  • No hay soporte para índices y consultas.
  • Solo permite operaciones simples, como Put(key, value), GET(key, value)y Eliminar (tecla)
  • Ninguna de las características familiares de un modelo de datos relacional, ya que no es una base de datos SQL. Los datos solo se pueden almacenar en pares clave-valor
  • Consultar grandes conjuntos de datos desde una base de datos LevelDB es ineficiente y complejo, ya que no se permiten consultas e índices complejos.

¿Qué es CouchDB?

La base de datos CouchDB es una base de datos orientada a documentos de código abierto implementada en Erlang que recopila y almacena datos en formato JSON. Los usuarios de Hyperledger Fabric pueden reemplazar su base de datos de estado mundial LevelDB predeterminada con una base de datos CouchDB, que también es la única alternativa disponible.

CouchDB es una base de datos NoSQL que permite consultas enriquecidas del contenido JSON almacenado. El lenguaje de consulta predeterminado en una base de datos de CouchDB es JavaScript y los datos se pueden almacenar sin un esquema establecido en formato JSON.

CouchDB admite índices y paginación. También puede realizar consultas basadas en claves, como con la base de datos LevelDB.

Ventajas de CouchDB

  • CouchDB permite consultas e índices JSON, lo que facilita el cumplimiento de los requisitos de informes y auditoría de red de Hyperledger Fabric que en LevelDB.
  • Como base de datos orientada a documentos, CouchDB le permite almacenar datos como matrices o diccionarios en la base de datos.
  • Los datos de CouchDB se exponen a través de un URI HTTP. Esto hace posible realizar operaciones HTTP ( GET, DELETE, PUT, POST) contra sus datos
  • CouchDB hace que la consulta de grandes conjuntos de datos de código de cadena sea más eficiente y flexible con índices

Limitaciones de CouchDB

  • CouchDB se ejecuta como una base de datos separada junto con la red Hyperledger Fabric
  • Se necesita más compromiso en términos de administración de bases de datos, instalación, configuraciones, etc. para ejecutar la red.

Elegir una base de datos estatal para su próximo proyecto de Hyperledger Fabric

Antes de elegir una base de datos estatal, debe saber que debe decidirse por una base de datos porque Hyperledger Fabric no le permite cambiar la base de datos después de que se haya lanzado la red Hyperledger Fabric.

Si está ejecutando un proyecto simple de Hyperledger Fabric con un bajo volumen de transacciones, la facilidad de uso y la velocidad de LevelDB lo hacen muy preferible de usar.

Sin embargo, para proyectos más complejos, es preferible utilizar una base de datos CouchDB. CouchDB tiene todas las funciones de la base de datos LevelDB, como obtener y configurar datos basados ​​en claves, pero también brinda acceso a funciones adicionales, como almacenar datos en formato JSON, índices, emitir consultas, paginación, etc., todo lo cual hace trabajar con datos más fácilmente.

Las funciones proporcionadas por CouchDB facilitan la gestión de una red Hyperledger Fabric con grandes volúmenes de transacciones. CouchDB también facilita el cumplimiento de los requisitos de auditoría e informes necesarios en una organización moderna que ejecuta una red Hyperledger Fabric.

Conclusión

En este artículo, hablamos sobre las opciones de bases de datos de estado mundial disponibles en Hyperledger Fabric, CouchDB y LevelDB. Explicamos las ventajas y limitaciones de cada base de datos y discutimos cómo elegir una base de datos para su próximo proyecto de Hyperledger Fabric.

Fuente: https://blog.logrocket.com/couchdb-vs-leveldb-comparing-state-database-options/

#leveldb #couchdb #hyperledger #fabric 

CouchDB Vs. LevelDB: Comparación De Las Opciones De La Base De Datos
Alex Rock

Alex Rock

1651751186

How Hyperledger Sawtooth Works for Supply Chain Issues?

Consumer desire for transparency, sustainability, and fair trade has increased the global supply chain management (SCM). To meet escalating customer demands, organizations must remodel non-integrated supply chain processes. Recent technical breakthroughs have the potential to tackle a variety of supply chain issues. Distributed ledger technology is one such innovation (commonly known as blockchain technology). With capabilities like traceability and provenance monitoring, it may eliminate significant flaws in the supply chain.


Leading manufacturing and retail companies are understanding the influence of blockchain technology on supply chains, particularly the development of Hyperledger applications. They are looking into ways to effectively track assets, increase transparency, and better the licensing of services, products, and software. Blockchain and automated smart contract payment solutions are effective means for achieving these objectives.

Supply Chain Industry's Difficulties

  • Processes that are stagnant, expensive, and resource-intensive
  • Issues with opacity and trust
  • Inadequate quality and compliance management
  • Data management and integration are difficult tasks.
  • Fraud and counterfeiting
  • Data that is untrustworthy and insecure

Advantages of Blockchain in Supply Chains

  • Transparency and traceability
  • Tracking in real time
  • Transactions are completed faster.
  • Untrustworthy chain
  • Elimination of errors and fraud
  • safer, more cost-effective, and efficient


Importance of Hyperledger Sawtooth for Improved SCM

Hyperledger Sawtooth is a business-grade blockchain technology that may be used to build industrial solutions. It improves SCM by recording traceability and provenance, which includes elements like temperature, humidity, and location. It enables firms to share information with customers and develop stronger relationships. Furthermore, hire hyperledger developer which is perfect for creating unique supply chain solutions for specific use cases.

Advantages of Hyperledger Sawtooth for the Supply Chain Industry

Smart Contracts for Streamlined Procure-to-Pay Processing

One of the most difficult difficulties in SCM is the necessity to follow up with customers for payments on a regular basis while generating time-consuming invoices. Sawtooth solves this problem by implementing automated delivery and payment via a digital contract (smart contract). Blockchain application developers implement a smart contract solution across an organization and integrate it with logistics suppliers and banks. The smart contract then sends proof of delivery to the logistics carrier and initiates the automatic payment and invoicing via the bank.

Enhanced Visibility and Cost-Effectiveness

Sawtooth can handle issues with tracking purchases between corporate partners, subsidiaries, and other supply chain stakeholders. Sawtooth accomplishes this by constantly refreshing its distributed digital ledger following each transaction and incorporating data from all stakeholders. As a result, stakeholders can view the total volume of purchases regardless of who supervised the activity. It also eliminates the need for each user to share their operational data with others.

Data and results have been improved.

The distributed ledger technology of Hyperledger Sawtooth improves the accountability and traceability of a range of supply chain data. It enables effective resource tracking and management at every stage of the supply chain, resulting in better forecasts, improved inventory management, and increased accuracy.

Seafood traceability is one application of the Sawtooth platform in supply chains.

Fish supply chain is being revolutionized.

Here's an example of how Sawtooth can be used to track the movement of fish from the ocean to the consumer.

Challenges:

Traditional fish supply systems are plagued by numerous issues. They include manual record-keeping errors, improper food storage conditions, unregulated fishing activities, and seafood fraud such as mislabeling. These challenges jeopardize food security and product quality while jeopardizing the economic security of the fishing business.

Solution:

The solution entails the deployment of a Sawtooth-based application as well as the integration of IoT sensors with ready-to-transport goods such as fish. It allows for the tracking of ownership, possession, and factors like as location, temperature, humidity, and motion. Finally, the buyer is given the option to double-check all recorded information to guarantee its trustworthiness and accuracy.

Benefits of a Blockchain-Operated Supply Chain

  • Transparency is required to build trust across the whole supply chain.
  • Suppliers should have equal opportunity, and there should be measures in place to encourage good behavior.
  • Automated procedures and operations to save money and time
  • Complete product visibility for both sellers and customers

Finally

One of Sawtooth's many real-world applications is redefining the fish supply chain. It has the potential to have a substantial impact on global supply chain norms. Blockchain is being investigated by a range of enterprises in order to ensure the legitimacy and correctness of transactions, shipping, and goods, as well as to generate funding options. We must now consider where to go from here in order to fully utilize the new possibilities presented by blockchain. Get in touch with a blockchain application development firm that specializes in offering blockchain solutions to a wide range of businesses. We can create blockchain-based apps in supply chain management to offer efficient and secure end-to-end visibility and monitoring throughout the supply chain.


#hyperledger #blockchain #hirehyperledgerdeveloper

 

Verificación KYC con Hyperledger Fabric and Go

Los procesos Know Your Customer (KYC) son soluciones adoptadas por empresas en una amplia gama de industrias para identificar y verificar clientes con el fin de autenticarlos para privilegios específicos. La verificación KYC es un punto crítico para las organizaciones porque a menudo es costosa, ineficiente y una fuente de frustración para los clientes.

En este artículo, mostraremos cómo se puede usar el marco de blockchain de Hyperledger Fabric, así como otras soluciones de blockchain, para agilizar el proceso de verificación de clientes para instituciones financieras que utilizan un sistema de identidad autónomo.

Hyperledger Fabric es una buena solución para los procesos contra el lavado de dinero (AML) y KYC porque está autorizado, se enfoca en la empresa y es capaz de administrar identidades.

Resumen de proyectos de Hyperledger

La creación e implementación de una dApp de Hyperledger Fabric no requiere un amplio conocimiento de todas las herramientas del ecosistema de Hyperledger . Por lo tanto, a los efectos de este artículo, he proporcionado sólo una breve introducción.

Los proyectos de Hyperledger se refieren a un número creciente de herramientas y marcos de código abierto proporcionados por la Fundación Linux en colaboración con otras organizaciones. Los proyectos de Hyperledger Fabric proporcionan una cadena de bloques privada autorizada que respalda el consumo empresarial y es administrada por el talento de la comunidad.

Además de ser de código abierto, los proyectos de Hyperledger comparten las siguientes características:

  • Construido por una comunidad abierta
  • Económico de construir y utilizar
  • Adopción fácil y rápida
  • Seguro y confiable debido al proceso continuo de revisión, actualización y aprobación de cambios en las tecnologías del proyecto por parte de la comunidad

Marcos y herramientas de Hyperledger

Al momento de escribir este artículo, hay 17 proyectos Hyperledger , algunos activos y otros en etapa de incubación. Estos proyectos pueden clasificarse de la siguiente manera:

  • Marcos de contabilidad distribuidos
    • indio
    • Tela
    • Iroha
    • Diente de sierra
    • Besu
    • Madriguera
  • bibliotecas
    • Aries
    • Colcha
    • Osa
    • Tramitar
  • Instrumentos
    • Calibrar
    • Violonchelo
    • Explorador
    • avalon
    • Bisel
    • Luciérnaga
  • Proyectos específicos de dominio
    • Red

En este artículo, nos centraremos en la tecnología de contabilidad distribuida de Hyperledger Fabric. Una aplicación de cadena de bloques creada con Hyperledger Fabric consta de una capa de consenso, una capa de contrato inteligente, una capa de comunicación y una capa de persistencia de datos. Dependiendo de la aplicación, también puede haber capas adicionales.

Hyperledger Fabric blockchain como solución empresarial

Los proyectos Hyperledger son la primera serie de proyectos que brindan soluciones empresariales en blockchain, lo que significa que automatizan los procesos comerciales mediante el uso de contratos inteligentes. Hay varios casos de uso para las soluciones empresariales de blockchain. En este artículo, exploraremos la digitalización de las credenciales de los clientes por parte de empresas y gobiernos.

Hyperledger Fabric es el proyecto más adoptado en el ecosistema Hyperledger. Esta tecnología de cadena de bloques de código abierto, privada y autorizada, basada en la empresa, admite la creación y gestión de soluciones de cadena de bloques de nivel empresarial de varios libros de contabilidad con códigos de cadena (término de Hyperledger para contratos inteligentes) escritos en lenguajes como Go, Node.js y Java. En este artículo, usaremos Go para la demostración del proceso de verificación KYC.

La tecnología Hyperledger Fabric ofrece las siguientes capacidades:

  • Gestión de identidades: el proveedor de servicios de membresía (MSP) de Hyperledger Fabric brinda soporte para la gestión de identidades
  • Privacidad y confidencialidad: Hyperledger Fabric ofrece canales privados que están fuera del alcance de compañeros o miembros sin permiso. Esto permite el intercambio seguro y privado de datos entre los miembros del canal.
  • Eficiencia: la función de concurrencia y paralelismo de Hyperledger Fabric mejora su rendimiento al permitir que las transacciones se encadenen y procesen más rápido.
  • Ejecución de código de cadena: los códigos de cadena son la lógica comercial en la red Fabric. Son responsables de ejecutar transacciones en cadena. La lógica de Chaincode está escrita en lenguajes de uso general, lo que hace posible que los desarrolladores creen códigos de cadena en el lenguaje con el que se sientan más cómodos.
  • Gobernanza: Hyperledger Fabric utiliza políticas de gobernanza para identificar a los pares que pueden implementar un código de cadena o agregar un MSP a un canal.
  • Arquitectura modular: la arquitectura modular de Hyperledger Fabric lo hace flexible a los cambios. Esta es probablemente la razón por la que esta cadena de bloques ha sido adoptada por empresas de una amplia gama de industrias (finanzas, banca, atención médica, fabricación, tecnología, IoT, cadena de suministro)

Descripción general del proceso de verificación KYC

La verificación Conozca a su cliente es un proceso para verificar la identidad y la autenticidad de un cliente (para una institución financiera) o un ciudadano (para un gobierno) con el uso de un sistema de prueba de identidad.

En la banca, el proceso de verificación KYC presenta un intercambio de documentos entre un cliente individual y una institución financiera que tiene la intención de trabajar juntos. El proceso incluye la recopilación y el almacenamiento de la información básica de identidad del cliente, como:

  • Prueba de identidad (POI): pasaporte, licencia de conducir, credencial de elector o tarjeta sanitaria
  • Comprobante de domicilio (POA): extracto bancario, factura de servicios públicos, comprobante de residencia emitido por un gobierno o documento de identidad
  • Datos biométricos: fotos o videos faciales, huellas dactilares, grabaciones de voz, reconocimiento de iris o escaneos de retina

El proceso de verificación KYC es generalmente una tarea engorrosa, insegura y costosa para las instituciones financieras. El proceso depende en gran medida de la gestión de identidades y accesos; la columna vertebral de todos los esfuerzos ALD de las instituciones financieras.

¿Cómo ayuda blockchain a la verificación KYC?

La tecnología Blockchain ofrece varias oportunidades para optimizar la verificación KYC e interrumpir las soluciones tradicionales de gestión de identidades:

  • Seguridad añadida : el almacenamiento de los documentos de identidad del cliente como archivos cifrados en la cadena es más seguro que los métodos tradicionales
  • Mayor eficiencia técnica : el contrato inteligente KYC responsable de administrar las credenciales digitales tendrá capacidades CRUD (crear, leer, actualizar y eliminar)
  • Inmutabilidad: los hashes criptográficos permiten que el libro mayor de blockchain permanezca como un registro permanente que no se puede modificar ni revertir
  • Privacidad añadida: Con blockchain, la entidad financiera solo valida al usuario y no tiene acceso a información sensible incluida en el documento de credencial
  • Precisión mejorada: el código de contrato administra el proceso en lugar de los humanos
  • Mayor transparencia : la información de verificación puede compartirse de forma segura entre instituciones financieras
  • Costo reducido: una vez que un cliente abre una cuenta y proporciona credenciales a una institución financiera, un contrato inteligente archiva y procesa el documento que contiene las credenciales. Luego, otras instituciones pueden acceder a ese contrato inteligente para verificar la identidad del cliente.

Un beneficio significativo de simplificar el proceso de verificación KYC en una cadena de bloques autorizada, como Hyperledger Fabric, es que solo los miembros autorizados y autorizados de la cadena pueden agregar o intercambiar datos de clientes.

Esto difiere drásticamente de una cadena de bloques pública y sin permisos, como Ethereum, en la que cualquier miembro de la red puede configurar un nodo y unirse al sistema simplemente con una dirección de Ethereum y sin identidad comprobada.

Demostración del flujo de trabajo de verificación KYC con Hyperledger Fabric and Go

Recorramos un proceso de verificación KYC de tres pasos utilizando Hyperledger Fabric blockchain y Go.

requisitos previos

Para nuestra demostración de flujo de trabajo de verificación KYC, necesitará lo siguiente:

  • Ir instalado en su máquina
  • Un editor de código, como VS Code

Paso 1: Cifrado de credenciales de identidad

Como primer paso, las credenciales de identidad de un cliente se recopilan como un documento y se cifran utilizando el algoritmo hash de la cadena de bloques. El valor cifrado del documento se almacena en la cadena y se produce un token que se entrega al cliente para su custodia. Cuando se verifique al cliente en el futuro, proporcionará este token para que pueda compararse con el valor cifrado almacenado en la cadena.

Supongamos que los detalles del cliente se guardan en un credential.csvarchivo, como este:

Name,ID,Phone
John, 10121,199823458

El código de cadena de Hyperledger Fabric es responsable de cifrar el documento. Tendría un algoritmo hash en su lógica como este:

package main

import (
    "crypto/sha256"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

func showFileToCustomer() {
    fmt.Println("Your document is: " + os.Args[0] + " credential.csv")
}

func checkArgs() string {
    if len(os.Args) < 2 {
        showFileToCustomer()
        os.Exit(1)
    }
    return os.Args[1]
}

func main() {
    credential := checkArgs()
    // Get bytes from the credential document
    data, err := ioutil.ReadFile(credential)
    if err != nil {
        log.Fatal(err)
    }

    // encrypt the file and display to the customer
    fmt.Printf("The encrypted file is: %x\n\n", sha256.Sum256(data))
}

Si guardamos este archivo en el mismo directorio que el credential.csvarchivo y luego lo ejecutamos, la salida resultante indicará que se ha modificado.

Paso 2: Almacenamiento de credenciales cifradas en la cadena

A continuación, la versión cifrada del credential.csvarchivo del cliente se convertirá en cadenas. Luego, se almacenará en la cadena de bloques donde no se podrá editar sin el permiso de los pares administradores de la cadena.

La versión encriptada de las credenciales actúa como recibo de la autenticidad de los documentos verificados. Una nueva institución financiera necesitaría solicitar el permiso del cliente para ver el recibo que el código de cadena almacena en la cadena. Esta solicitud se haría usando una lógica similar a esta:

package shim

import (
    "bytes"
    "os"
    "strconv"
    "strings"
    "testing"
    "github.com/hyperledger/fabric/common/flogging"
    mockpeer "github.com/hyperledger/fabric/common/mocks/peer"
    "github.com/hyperledger/fabric/common/util"
    lproto "github.com/hyperledger/fabric/protos/ledger/queryresult"
    protobuf "github.com/hyperledger/fabric/protos/peer"
    "github.com/hyperledger/fabric/protos/utils"
)

err = stub.PutState(A, []byte(strconv.Itoa(data)))
if err != nil {
    return Error(err.Error())
    }

Paso 3: Recuperación y consulta de credenciales de identidad

El cliente da su consentimiento a la solicitud de verificación al proporcionar su identificación hash para verificación cruzada o consulta. Esto es recuperado y consultado por el código de cadena usando una lógica similar a esta:

func (t *shimTestCC) logsQ(stub ChaincodeStubInterface, args []string) protobuf.Response {
    if len(args) < 1 {
        return Error("Incomplete args. Needs 1")
    }

    credentials := args[0]
    iterateResult, err := stub.GetKeyHistory(id)

    if err != nil {
        return Error(err.Error())
    }

    defer iterateResult.Close()
    var buffer bytes.Buffer
    buffer.WriteString("[")
    WriteArrayMem := false
    for resultsIterator.HasNext() {
        response, err := resultsIterator.Next()
        if err != nil {
            return Error(err.Error())
        }

        // Add a comma before array members, suppress it for the first array member
        if WriteArrayMem == true {
            buffer.WriteString(",")
        }

        buffer.WriteString("{\"TransactionId\":")
        buffer.WriteString("\"")
        buffer.WriteString(response.TransactionId)
        buffer.WriteString("\"")
        buffer.WriteString(", \"Value\":")

        if response.IsDelete {
            buffer.WriteString("null")
        } else {
            buffer.WriteString(string(response.Value))
        }

        buffer.WriteString(", \"IsDelete\":")
        buffer.WriteString("\"")
        buffer.WriteString(strconv.FormatBool(response.IsDelete))
        buffer.WriteString("\"")
        buffer.WriteString("}")
        bArrayMemberAlreadyWritten = true
    }

    buffer.WriteString("]")
    return Success(buffer.Bytes())
}

Una vez que hay una coincidencia, se completa el proceso de verificación KYC.

El código de cadena supervisa todo el proceso y registra los nombres de las instituciones financieras por motivos de seguridad.

Conclusión

En este artículo, revisamos una introducción a las herramientas y marcos del proyecto Hyperledger. También exploramos la cadena de bloques Hyperledger Fabric y el proceso KYC.

Demostramos cómo se puede simplificar la verificación KYC con el marco de la cadena de bloques Hyperledger Fabric y el lenguaje de programación Go en un proceso de tres pasos: cifrado, almacenamiento y consulta/verificación.

Hay varias implementaciones de algoritmos de consulta y almacenamiento diferentes con Hyperledger Fabric, como GenesisKYC . A medida que practique la escritura del código de cadena de Hyperledger Fabric, debería poder reestructurar el código para que se ajuste a sus necesidades específicas. Para obtener información adicional sobre Hyperledger Fabric, consulte GitHub

Fuente: https://blog.logrocket.com/streamline-kyc-verification-hyperledger-fabric-go/

#hyperledger #go 

Verificación KYC con Hyperledger Fabric and Go
渚  直樹

渚 直樹

1649998864

Hyperledger FabricとGoを使用したKYC検証

Know Your Customer(KYC)プロセスは、特定の特権について顧客を認証するために顧客を識別および検証するために、さまざまな業界の企業によって採用されているソリューションです。KYC検証は、多くの場合、コストがかかり、非効率的であり、顧客のフラストレーションの原因となるため、組織にとっての問題点です。

この記事では、Hyperledger Fabricブロックチェーンフレームワークやその他のブロックチェーンソリューションを使用して、セルフソブリンIDシステムを使用する金融機関の顧客検証プロセスを合理化する方法を紹介します。

Hyperledger Fabricは、許可されており、企業に焦点を合わせており、ID管理が可能なため、マネーロンダリング防止(AML)およびKYCプロセスに適したソリューションです。

Hyperledgerプロジェクトの概要

Hyperledger Fabric dAppの構築と展開には、Hyperledgerエコシステムのすべてのツールに関する広範な知識は必要ありません。したがって、この記事の目的のために、簡単な紹介のみを提供しました。

Hyperledgerプロジェクトとは、LinuxFoundationが他の組織と協力してプロビジョニングするオープンソースツールとフレームワークの数が増えていることを指します。Hyperledger Fabricプロジェクトは、企業の消費をサポートし、コミュニティの才能によって管理される許可されたプライベートブロックチェーンを提供します。

オープンソースであることに加えて、Hyperledgerプロジェクトは次の機能を共有しています。

  • オープンコミュニティによって構築されました
  • 構築して利用するのに経済的
  • 簡単かつ迅速な採用
  • プロジェクトテクノロジの変更に対する継続的なコミュニティのレビュー、更新、および承認プロセスにより、安全で信頼性が高い

Hyperledgerのフレームワークとツール

この記事の執筆時点では、17のHyperledgerプロジェクトがあり、一部はアクティブで、その他はインキュベーション段階にあります。これらのプロジェクトは、次のように分類できます。

  • 分散型台帳フレームワーク
    • インディ
    • ファブリック
    • いろは
    • のこぎり歯
    • ベス
    • 潜る
  • ライブラリ
    • 牡羊座
    • キルト
    • ウルサ
    • 取引
  • ツール
    • キャリパー
    • チェロ
    • 冒険者
    • アバロン
    • 斜角
    • ファイアフライ
  • ドメイン固有のプロジェクト
    • グリッド

この記事では、HyperledgerFabric分散型台帳テクノロジーに焦点を当てます。Hyperledger Fabricで構築されたブロックチェーンアプリケーションは、コンセンサスレイヤー、スマートコントラクトレイヤー、通信レイヤー、およびデータ永続化レイヤーで構成されます。アプリケーションによっては、追加のレイヤーが存在する場合もあります。

エンタープライズソリューションとしてのHyperledgerFabricブロックチェーン

Hyperledgerプロジェクトは、ブロックチェーン上でエンタープライズソリューションを提供する最初の一連のプロジェクトです。つまり、スマートコントラクトを使用してビジネスプロセスを自動化します。ブロックチェーンエンタープライズソリューションにはいくつかのユースケースがあります。この記事では、企業や政府による顧客の資格情報のデジタル化について説明します。

Hyperledger Fabricは、Hyperledgerエコシステムで最も広く採用されているプロジェクトです。このプライベートで許可されたエンタープライズベースのオープンソースブロックチェーンテクノロジーは、Go、Node.js、Javaなどの言語で記述されたチェーンコード(Hyperledgerのスマートコントラクトの用語)を使用して、マルチレジャーのエンタープライズグレードのブロックチェーンソリューションの作成と管理をサポートします。この記事では、KYC検証プロセスのデモにGoを使用します。

Hyperledger Fabricテクノロジーは、次の機能を提供します。

  • ID管理: Hyperledger Fabricのメンバーシップサービスプロバイダー(MSP)は、ID管理のサポートを提供します
  • プライバシーと機密性: Hyperledger Fabricは、許可なくピアまたはメンバーからの範囲外のプライベートチャネルを提供します。これにより、チャネルメンバー間での安全なプライベートデータ共有が可能になります。
  • 効率: Hyperledger Fabricの同時実行および並列処理機能により、トランザクションのスレッド化と処理が高速化され、パフォーマンスが向上します。
  • チェーンコードの実行:チェーンコードは、ファブリックネットワーク上のビジネスロジックです。彼らはチェーン上でトランザクションを実行する責任があります。チェーンコードロジックは汎用言語で記述されているため、開発者は最も快適な言語でチェーンコードを作成できます。
  • ガバナンス: Hyperledger Fabricは、ガバナンスポリシーを利用して、チェーンコードを展開したり、チャネルにMSPを追加したりできるピアを識別します。
  • モジュラーアーキテクチャ: Hyperledger Fabricのモジュラーアーキテクチャにより、変更に柔軟に対応できます。これが、このブロックチェーンがこのような幅広い業界(金融、銀行、ヘルスケア、製造、テクノロジー、IoT、サプライチェーン)の企業に採用されている理由である可能性があります。

KYC検証プロセスの概要

Know Your Customer検証は、ID証明システムを使用して、顧客(金融機関の場合)または市民(政府の場合)のIDと信頼性を検証するプロセスです。

銀行業務では、KYC検証プロセスは、個々の顧客と協力することを意図している金融機関との間の文書の交換を特徴としています。このプロセスには、次のような顧客の基本的なID情報の収集と保存が含まれます。

  • 身分証明書(POI):パスポート、運転免許証、有権者IDカード、または健康カード
  • 住所証明(POA):銀行取引明細書、公共料金請求書、政府発行の居住証明書、または身分証明書
  • 生体認証データ:顔写真またはビデオ、指紋、音声録音、虹彩認識、または網膜スキャン

KYC検証プロセスは、一般的に、金融機関にとって面倒で、安全でなく、コストのかかる作業です。このプロセスは、IDとアクセスの管理に大きく依存しています。すべての金融機関のAMLの取り組みのバックボーン。

ブロックチェーンはKYC検証にどのように役立ちますか?

ブロックチェーンテクノロジーは、KYC検証を合理化し、従来のID管理ソリューションを混乱させるためのいくつかの機会を提供します。

  • セキュリティの強化:顧客IDドキュメントを暗号化されたファイルとしてチェーンに保存する方が、従来の方法よりも安全です。
  • 技術効率の向上:デジタルクレデンシャルの管理を担当するKYCスマートコントラクトには、CRUD(作成、読み取り、更新、および削除)機能があります
  • 不変性:暗号化ハッシュにより、ブロックチェーン元帳を変更または元に戻すことができない永続的なレコードとして残すことができます
  • プライバシーの追加:ブロックチェーンを使用すると、金融機関はユーザーを検証するだけで、資格情報に含まれる機密情報にアクセスできません。
  • 精度の向上:契約コードが人間ではなくプロセスを管理します
  • 透明性の向上:検証情報を金融機関間で安全に共有できる
  • コストの削減:顧客がアカウントを開設して1つの金融機関に資格情報を提供すると、スマートコントラクトは資格情報を含むドキュメントをアーカイブしてハッシュします。その後、他の機関は、顧客の身元を確認するためにそのスマートコントラクトにアクセスできます

Hyperledger Fabricのような許可されたブロックチェーンでKYC検証プロセスを合理化することの重要な利点は、チェーンの許可されたメンバーと許可されたメンバーだけが顧客データを追加または交換できることです。

これは、ネットワーク上のすべてのメンバーがノードをセットアップし、Ethereumアドレスだけでシステムに参加でき、証明されたIDがないEthereumなどの許可のないパブリックブロックチェーンとは劇的に異なります。

Hyperledger FabricandGoを使用したKYC検証ワークフローのデモ

HyperledgerFabricブロックチェーンとGoを使用した3ステップのKYC検証プロセスを見ていきましょう。

前提条件

KYC検証ワークフローのデモでは、次のものが必要です。

  • マシンにインストールしてください
  • VSCodeなどのコードエディタ

ステップ1:IDクレデンシャルを暗号化する

最初のステップとして、顧客のIDクレデンシャルがドキュメントとして収集され、ブロックチェーンのハッシュアルゴリズムを使用して暗号化されます。ドキュメントの暗号化された値はチェーン上に保存され、トークンが生成されて顧客に渡され、保管されます。顧客が将来確認されるときに、このトークンを提供して、チェーンに保存されている暗号化された値と比較できるようにします。

顧客の詳細が次のcredential.csvようにファイルに保存されていると仮定します。

Name,ID,Phone
John, 10121,199823458

Hyperledger Fabricチェーンコードは、ドキュメントの暗号化を担当します。ロジックには次のようなハッシュアルゴリズムがあります。

package main

import (
    "crypto/sha256"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

func showFileToCustomer() {
    fmt.Println("Your document is: " + os.Args[0] + " credential.csv")
}

func checkArgs() string {
    if len(os.Args) < 2 {
        showFileToCustomer()
        os.Exit(1)
    }
    return os.Args[1]
}

func main() {
    credential := checkArgs()
    // Get bytes from the credential document
    data, err := ioutil.ReadFile(credential)
    if err != nil {
        log.Fatal(err)
    }

    // encrypt the file and display to the customer
    fmt.Printf("The encrypted file is: %x\n\n", sha256.Sum256(data))
}

このファイルをファイルと同じディレクトリに保存してcredential.csv実行すると、結果の出力はハッシュされたことを示します。

ステップ2:暗号化されたクレデンシャルをチェーンに保存する

次に、顧客のcredential.csvファイルの暗号化されたバージョンが文字列に変換されます。その後、ブロックチェーンに保存され、チェーン上の管理ピアの許可なしに編集することはできません。

暗号化されたバージョンのクレデンシャルは、検証されたドキュメントの信頼性の領収書として機能します。新しい金融機関は、チェーンコードによってチェーンに保存されているレシートを表示するために顧客の許可を要求する必要があります。この要求は、次のようなロジックを使用して行われます。

package shim

import (
    "bytes"
    "os"
    "strconv"
    "strings"
    "testing"
    "github.com/hyperledger/fabric/common/flogging"
    mockpeer "github.com/hyperledger/fabric/common/mocks/peer"
    "github.com/hyperledger/fabric/common/util"
    lproto "github.com/hyperledger/fabric/protos/ledger/queryresult"
    protobuf "github.com/hyperledger/fabric/protos/peer"
    "github.com/hyperledger/fabric/protos/utils"
)

err = stub.PutState(A, []byte(strconv.Itoa(data)))
if err != nil {
    return Error(err.Error())
    }

ステップ3:IDクレデンシャルの取得とクエリ

顧客は、クロスチェックまたはクエリ用にハッシュされたIDを提供することにより、検証要求に同意します。これは、次のようなロジックを使用してチェーンコードによって取得および照会されます。

func (t *shimTestCC) logsQ(stub ChaincodeStubInterface, args []string) protobuf.Response {
    if len(args) < 1 {
        return Error("Incomplete args. Needs 1")
    }

    credentials := args[0]
    iterateResult, err := stub.GetKeyHistory(id)

    if err != nil {
        return Error(err.Error())
    }

    defer iterateResult.Close()
    var buffer bytes.Buffer
    buffer.WriteString("[")
    WriteArrayMem := false
    for resultsIterator.HasNext() {
        response, err := resultsIterator.Next()
        if err != nil {
            return Error(err.Error())
        }

        // Add a comma before array members, suppress it for the first array member
        if WriteArrayMem == true {
            buffer.WriteString(",")
        }

        buffer.WriteString("{\"TransactionId\":")
        buffer.WriteString("\"")
        buffer.WriteString(response.TransactionId)
        buffer.WriteString("\"")
        buffer.WriteString(", \"Value\":")

        if response.IsDelete {
            buffer.WriteString("null")
        } else {
            buffer.WriteString(string(response.Value))
        }

        buffer.WriteString(", \"IsDelete\":")
        buffer.WriteString("\"")
        buffer.WriteString(strconv.FormatBool(response.IsDelete))
        buffer.WriteString("\"")
        buffer.WriteString("}")
        bArrayMemberAlreadyWritten = true
    }

    buffer.WriteString("]")
    return Success(buffer.Bytes())
}

一致するものがあれば、KYC検証プロセスが完了します。

チェーンコードはプロセス全体を監視し、セキュリティ上の目的で金融機関の名前を記録します。

結論

この記事では、Hyperledgerプロジェクトのツールとフレームワークの概要を確認しました。また、HyperledgerFabricブロックチェーンとKYCプロセスについても説明しました。

Hyperledger FabricブロックチェーンフレームワークとGoプログラミング言語を使用してKYC検証を合理化し、暗号化、ストレージ、クエリ/検証の3つのステップのプロセスにする方法を示しました。

GenesisKYCなど、HyperledgerFabricにはいくつかの異なるストレージおよびクエリアルゴリズムの実装があります。Hyperledger Fabricチェーンコードの記述を練習すると、特定のニーズに合わせてコードを再構築できるはずです。Hyperledger Fabricの詳細については、GitHubを参照してください。 

ソース:https ://blog.logrocket.com/streamline-kyc-verification-hyperledger-fabric-go/

#hyperledger #go 

Hyperledger FabricとGoを使用したKYC検証
高橋  花子

高橋 花子

1648908000

HyperledgerSawtoothの穏やかな紹介

Hyperledger Sawtoothは、Hyperledger傘下のオープンソースプロジェクトです。これは、分散型台帳アプリケーションとネットワークの作成と運用に使用されるエンタープライズレベルのブロックチェーンシステムとして機能し、特に企業で使用されます。

Hyperledger Sawtoothは、コアシステムの基本的な設計を知らなくても、カスタマイズされたスマートコントラクトとロジックを実行できる、エンタープライズのサービスとしてのブロックチェーンプラットフォームと呼ばれています。また、実用的なビザンチンフォールトトレランス(PBFT)や経過時間の証明(PoET)など、さまざまなコンセンサスアルゴリズムをサポートしているため、ユーザーは特定の要件に応じて最適な方法でブロックチェーンのパフォーマンスを作成できます。

Hyperledgerは、Linux Project、IBM、Intel、SAPなどの組織が後援する開発グループです。

のこぎり歯の特異点

鋸歯状のコンセンサスアルゴリズム

ブロックチェーンアーキテクチャの堅牢性の中心にあり、最も一般的な方法では、パブリック元帳にコンセンサスアルゴリズムがあります。最も伝統的なものは、ビザンチンフォールトトレラント(BFT)コンセンサスの限界を克服するために設計された坂本コンセンサスアルゴリズム[2]です。Hyperledger Sawtoothは、PoET、PBFT、およびRaftの3つの異なるコンセンサスメカニズムを提供します。

のこぎりの詩人

Sawtooth Proof of Elapsed Time(PoET)は、大規模なネットワーク人口をサポートするように設計されたナカモトスタイルのコンセンサス[2]アルゴリズムです。PoETは、「公正な宝くじ」メカニズムに依存して、次のブロックを追加するノードを選択します。各ノードは、ノードがスリープする必要があるランダムな待機時間を生成します。待ち時間が最も短いノードが最初にウェイクアップして宝くじに当選するため、新しいブロックをブロックチェーンにコミットすることができます。もちろん、ノードがブロックを配置しようとしてエネルギーを浪費しないため、PoETの方がエネルギー効率が高くなります。

のこぎり歯PBFT

Sawtooth Practical Byzantine Fault Tolerance(PBFT)(元のPBFT [3]に対する修正バージョン)は、ビザンチンフォールトトレランスを提供する投票ベースのコンセンサスアルゴリズムです。ノードがセットに追加されると、メッセージ数が指数関数的に増加するという欠点があります。

リーダーノードが追加する新しいブロックを提案すると、ノード間で交換される一連のメッセージが開始されます。このアルゴリズムは、実装に依存する悪意のあるノードの割合に対して証明可能な耐性を提供します。

のこぎりいかだ

Raftは、クラッシュフォールトトレランス(CFT)を提供するリーダーベースのコンセンサスアルゴリズムです。システムの要は、常に正直に行動すると想定されるリーダーです。リーダーによって追加されたブロックは偽造されておらず、その更新は信頼できます。

リーダーには、リーダーからの更新を単純に伝播するノードのコホートがあり、特定のタイムアウト後にリーダーにクラッシュが発生した場合、フォロワーの中から新しいリーダーが選出されます。

このアルゴリズムは、CFTに対して自然な回復力を持っています。たとえば、6つのノードのネットワークでは、新しいリーダーを選出するためのクォーラムは4つです(使用可能な6つのノードの半分以上)。

 

Raftには、ノード間にブロックを追加する競合がなく、CPU時間を浪費するため、PBFTやPoETよりも効率的であるという利点があります(エネルギーの観点からも)。リーダーが稼働している限り、更新は単純に伝播されます。

開発モードのコンセンサス

Sawtoothが提供するdevmodeコンセンサスアルゴリズムについて簡単に説明し、開発者がコンセンサスアルゴリズムを最初から作成する方法を理解できるようにします。

開発モードは、ご存知のとおり、開発モードでのみ使用されるコンセンサスアルゴリズムです。クラッシュ耐性がなく、単純な単純化されたランダムリーダーの選択を使用します。

討論

上記のアルゴリズムは、いくつかの理由で従来のPoWコンセンサスとは異なります。

  • Sawtoothは、Proof of Work(PoW)やProof of Elapsed Time(PoET)などの宝くじスタイルのコンセンサスアルゴリズムとは異なり、ノードによってコミットされたブロック間のコラボレーションが最終的なシナリオ向けに設計されています。
  • pBFTは通常、スケーリングしないアルゴリズムと考えられています。この認識は通常、ノード==サーバーの概念によってもたらされます。これは、エンタープライズ実稼働環境に展開された場合のpBFTの場合には当てはまりません。
  • pBFTは、各組織がネットワークノード==組織上のノードを表すエンタープライズ組織のコンソーシアムで使用する必要があります。これらの各組織ノードには、ノードのエンドポイントの背後にインスタンスとロードバランサーのクラスターがあり、計算能力をスケーリングして迅速な応答時間を確保する必要があります。

サンプルアプリケーション:単一ノードのSawtoothインストールをデプロイします

この段落では、簡単にするために、デモに必要な基本コンポーネントのみを含む非常に単純なDockerファイルから開始して、単一ノードのSawtoothインストールをデプロイすることから始めます。

特に、バリデーター、REST API、開発モードコンセンサスエンジン、および3つのトランザクションプロセッサを実行する単一のバリデーター設定をデプロイします。環境は、開発モードのコンセンサスと並列トランザクション処理を使用します。

 

これがより強力な設定とどのように異なるかをよりよく理解するために、4つのバリデーターノード設定と比較してみましょう。

 

より現実的な設定に関するもう1つの単純化は、上記のdevモードコンセンサスアルゴリズムを使用することです。システムが機能したら、これをより賢明なコンセンサスアルゴリズムに変更する方法を説明します。

リポジトリとセットアップ

便宜上、GitHubにリポジトリを用意しています。https://github.com/rosdec/singleから選択したディレクトリにクローンを作成するだけです。推奨される設定は選択したLinuxでの設定ですが、さらにハンマーを使用すると、WindowsまたはMacOSで簡単に機能することに注意してください。

一部のライブラリはノードのバージョンにこだわりがあるため、ノード12を使用してください。依存関係をインストールすると、すべてを実行できるようになります(詳細な手順は、リポジトリのREADMEにあります)。

サンプルアプリケーションの出力は非常に単純で、その背後にあるロジック全体は派手ではありません。ペイロード(文字列)をブロックチェーンの特定のアドレスに格納し、それを取得してすべてが期待どおりに機能することを確認します。

 

コードを詳しく調べると、内部で何が起こっているのかを理解するのに役立ち、Sawtoothの背後にあるアイデアを理解することもできます。

ソースコード検査

サンプルアプリケーションのコアは、プロセッサ(ファイルプロセッサ/processor.js)とインタラクション(ファイルinteract.js)の2つの部分に分けることができます。

プロセッサは、Hyperledger Sawtoothの可能性を最大限に発揮するサンプルトランザクションプロセッサです。トランザクションとは何か、およびトランザクションがブロックチェーンストレージとどのように相互作用するかを定義できます。

これは、トランザクションがストレージと対話する固定された方法を持ち、主に2つ以上のアカウント間でイーサリアムまたはビットコインを移動する従来のブロックチェーン(もちろん、イーサリアムやビットコインなど)と比較して大きな飛躍です。

Sawtoothでは、任意の言語で独自のプロセッサを作成できます。サンプルアプリケーションでは、プロセッサはトランザクションペイロード(文字列)を特定のアドレスに格納するだけです(42行目)。ただし、スマートコントラクトなどの代わりに、トランザクションレベルでより多くのロジックを配置することで、より複雑なインタラクションを設計できます。

 

これは、Sawtoothを使用することの大きな利点です。これは、ブロックチェーンの独自のフレーバーを作成するためのフレームワークであり、ロジックをトランザクションで直接プッシュできますが、必ずしもスマートコントラクトではプッシュできません。この柔軟性の例として、三目並べゲームを処理するトランザクションプロセッサが記述されているこのリポジトリを確認できます。

ブロックチェーンとの対話には2つのメソッドとがwrite_dataありread_data、どちらもREST APIを介して操作することでブロックチェーンと対話します(上の図のブロックを参照)。ブロックチェーンからの読み取りは非常に簡単です。これは、読み取るアドレスを使用したAPI/stateの呼び出しにすぎません。

 

一方、ブロックチェーンへの書き込みは、特定の一連のステップで構成されます。あなたはinteract.jsファイルでそれらに従うことができます:

  1. 最初に、トランザクションヘッダーが作成されます。これは、最も重要なこととして、トランザクションファミリーを含みます。つまり、トランザクションを処理するために呼び出されるトランザクションプロセッサです(48〜58行目)。次に、トランザクションは、それを送信しているサブジェクトの秘密鍵を使用して署名されます(61〜66行目)。
  2. トランザクションはバッチ内で収集され、バッチはさまざまなサブジェクトからのトランザクションを収集でき、それ自体が署名されます(69〜81行目)。
  3. 署名されたトランザクションのバッチの準備ができたら、API呼び出しで安全に使用できるように(行89〜93)、​​エンコードされます(行84〜86)。

コンセンサスアルゴリズムの変更

ソースコードを調べた後、Dockerで作成された。という名前のファイルを見てみましょうsingle-node.yaml。上記の5つのコンポーネントが正確に含まれています。

  1. ロジックがprocessor.jsファイルに記述されているトランザクションプロセッサ。
  2. バインドするポートを指定するだけのSawtoothRESTAPI。
  3. ブロックチェーンに保持されている設定との対話を可能にする必須の設定トランザクションプロセッサ。
  4. バリデーターは、バリデーターノードの構成を記述します。ご想像のとおり、ここでコンセンサスアルゴリズムが指定されます(48行目)。このバージョンでは、開発モードアルゴリズムを使用するように指定されています。
  5. devmodeエンジンには、この特定のアルゴリズムの(いくつかの)構成が含まれています

コンセンサスアルゴリズムの変更は非常に簡単です。使用するアルゴリズムを選択して、バリデーターノードの構成を変更するだけです。わかりやすくするために、単一ノードで快適に動作する開発モードエンジンを使用しました。より複雑なアルゴリズムには少なくとも4つのノードが必要であり、一貫して、docker-composeファイルはより複雑です。

例として、コンセンサスアルゴリズムとしてpBFTを使用するための構成を含むGitHub(138行目)と、このシナリオで使用するためにそのようなアルゴリズムがどのように設定されているか(300〜304行目)を確認します。pBFTが機能するには少なくとも4つのノードが必要です(リーダーの選出のため)。したがって、4つのバリデーターノードと、同様に、各バリデーターに1つずつ4つのpBFTエンジンがあります。

結論

Hyperledger Sawtoothは、さまざまなブロックチェーン構成に対応できるため、トランザクションの方法と手段をカスタマイズできます。ブロックチェーンが実際に動作する方法の中心となるコンセンサスアルゴリズムは構成可能であり、ブロックチェーンのパフォーマンスとビザンチン攻撃への耐性を慎重に選択するために、すぐに使用できる一連のオプションを利用できます。

ソース:https ://blog.logrocket.com/hyperledger-sawtooth-introduction/ 

#hyperledger #sawtooth 

HyperledgerSawtoothの穏やかな紹介

Una Suave introducción A Hyperledger Sawtooth

Hyperledger Sawtooth es un proyecto de código abierto bajo el paraguas de Hyperledger. Funciona como un sistema de cadena de bloques de nivel empresarial que se utiliza para crear y operar aplicaciones y redes de registros distribuidos, particularmente para uso de empresas.

Hyperledger Sawtooth se conoce como una plataforma empresarial de cadena de bloques como servicio que puede ejecutar contratos inteligentes personalizados y lógica sin necesidad de conocer el diseño subyacente del sistema central. También es compatible con una variedad de algoritmos de consenso, incluida la tolerancia práctica a fallas bizantinas (PBFT) y la prueba de tiempo transcurrido (PoET), lo que permite al usuario diseñar el rendimiento de la cadena de bloques de la manera más adecuada según los requisitos específicos.

Hyperledger es un grupo de desarrollo patrocinado por organizaciones como Linux Project, IBM, Intel y SAP.

Singularidades de diente de sierra

Algoritmos de consenso de diente de sierra

En el núcleo mismo de la solidez de la arquitectura de la cadena de bloques y, en general, de los libros de contabilidad públicos, se encuentra el algoritmo de consenso. El más tradicional es el Algoritmo de Consenso de Sakamoto [2] que fue diseñado para superar los límites del Consenso de Tolerancia a Fallos Bizantinos (BFT). Hyperledger Sawtooth proporciona tres mecanismos de consenso diferentes: PoET, PBFT y Raft.

PoET diente de sierra

Sawtooth Proof of Elapsed Time (PoET) es un algoritmo de consenso al estilo de Nakamoto [2] que está diseñado para admitir grandes poblaciones de redes. PoET se basa en un mecanismo de "lotería justa" para seleccionar qué nodo agregará el siguiente bloque: cada nodo genera un tiempo de espera aleatorio durante el cual los nodos deben dormir. El nodo con el tiempo de espera más corto se despertará primero y ganará la lotería, lo que le permitirá enviar un nuevo bloque a la cadena de bloques. Por supuesto, PoET es más eficiente energéticamente porque los nodos no desperdiciarán energía tratando de colocar bloques.

PBFT de diente de sierra

Sawtooth Practical Byzantine Fault Tolerance (PBFT) (versión modificada con respecto al PBFT original [3]) es un algoritmo de consenso basado en votación que proporciona tolerancia a fallas bizantinas. Viene con el inconveniente de un recuento de mensajes que aumenta exponencialmente a medida que se agregan nodos al conjunto.

Una vez que el nodo líder propone agregar un nuevo bloque, comienza una serie de mensajes intercambiados entre los nodos. El algoritmo proporciona una resistencia demostrable a un porcentaje de nodos maliciosos que depende de la implementación.

balsa de dientes de sierra

Raft es un algoritmo de consenso basado en líder que proporciona tolerancia a fallas de choque (CFT): la piedra angular del sistema es el líder que se supone que siempre actúa con honestidad. Los bloques agregados por el líder no han sido falsificados y sus actualizaciones son confiables.

El líder tiene una cohorte de nodos que simplemente propagarán las actualizaciones del líder y, en caso de que el líder se bloquee después de un tiempo de espera determinado, se elige un nuevo líder entre los seguidores.

Este algoritmo tiene una resistencia natural a CFT. Por ejemplo, en una red de seis nodos, el quórum para elegir un nuevo líder es de cuatro (uno más de la mitad de los seis nodos disponibles).

 

Raft tiene la ventaja de ser más eficiente (también desde el punto de vista energético) que PBFT y PoET porque no hay competencia para agregar bloques entre nodos, desperdiciando tiempo de CPU; las actualizaciones simplemente se propagan siempre que el líder esté en funcionamiento.

Consenso del modo de desarrollo

Describamos brevemente el algoritmo de consenso devmode que proporciona Sawtooth para que los desarrolladores entiendan cómo escribir un algoritmo de consenso desde cero.

El modo Dev es, como el más inteligente de ustedes ya entendió, un algoritmo de consenso que se usa solo en el modo de desarrollo: no tiene tolerancia a fallas y usa una selección de líder aleatorio simple y simplificada.

Discusión

Los algoritmos anteriores difieren del consenso PoW clásico por algunas razones:

  • Sawtooth está diseñado para un escenario en el que la colaboración entre los bloques comprometidos por los nodos es definitiva, a diferencia de los algoritmos de consenso de tipo lotería, como la Prueba de trabajo (PoW) o la Prueba de tiempo transcurrido (PoET)
  • pBFT se considera comúnmente como un algoritmo que no escala. Esta percepción generalmente es provocada por la noción de un nodo == servidor, lo que no debería ser el caso con pBFT cuando se implementa en un entorno de producción empresarial.
  • pBFT debe usarse con un consorcio de organizaciones empresariales, donde cada organización representaría un nodo en la red nodo == organización. Cada uno de estos nodos organizacionales debe tener grupos de instancias y balanceadores de carga detrás del punto final del nodo para escalar la potencia computacional y garantizar un tiempo de respuesta rápido.

Una aplicación de muestra: implementar una instalación Sawtooth de un solo nodo

En este párrafo, comenzaremos implementando una instalación de Sawtooth de un solo nodo a partir de un archivo Docker muy simple que, en aras de la simplicidad, contiene solo los componentes básicos necesarios para la demostración.

En particular, implementaremos una única configuración de validador que ejecuta un validador, una API REST, el motor de consenso del modo de desarrollo y tres procesadores de transacciones. El entorno utiliza el consenso del modo de desarrollo y el procesamiento de transacciones en paralelo.

 

Para comprender mejor cuán diferente es esto de una configuración más potente, comparémoslo con una configuración de cuatro nodos de validación:

 

Otra simplificación, con respecto a una configuración más realista, es que usaremos el algoritmo de consenso del modo desarrollador descrito anteriormente. Explicaré cómo cambiar esto a un algoritmo de consenso más sensato una vez que el sistema funcione.

El repositorio y la configuración

Hemos proporcionado un repositorio en GitHub para su comodidad: solo tiene que clonar desde https://github.com/rosdec/single en un directorio de su elección. Tenga en cuenta que la configuración sugerida está bajo un Linux de elección, pero con un poco más de martillazos, funcionará fácilmente bajo Windows o Mac OS.

Use Node 12 porque algunas de las bibliotecas son exigentes con la versión de Node. Instale las dependencias y todo estará listo para ejecutarse (las instrucciones adicionales y detalladas se encuentran en el LÉAME del repositorio).

La aplicación de muestra tiene una salida muy simple y toda la lógica detrás de ella no es elegante: simplemente almacenará la carga útil (una cadena) en una dirección específica de la cadena de bloques y la recuperará para verificar que todo funcione como se esperaba.

 

Una inspección más cercana del código ayudará a comprender lo que sucede debajo del capó y también nos permitirá captar la idea detrás de Sawtooth.

Inspección de código fuente

El núcleo de la aplicación de ejemplo se puede dividir en dos partes: el procesador (archivo procesador/procesador.js) y las interacciones (archivo interact.js).

El procesador es un procesador de transacciones de muestra que expresa todo el potencial de Hyperledger Sawtooth: puede definir qué es una transacción y cómo interactúa con el almacenamiento de la cadena de bloques.

Este es un gran salto con respecto a las cadenas de bloques tradicionales (por ejemplo, Ethereum y Bitcoin, por supuesto) donde las transacciones tienen una forma fija de interactuar con el almacenamiento, principalmente moviendo ethers o bitcoins entre dos o más cuentas.

En Sawtooth, puede escribir su propio procesador en cualquier idioma que prefiera. En la aplicación de muestra, nuestro procesador simplemente almacenará la carga útil de la transacción (una cadena) en una dirección específica (línea 42). Pero puede diseñar interacciones mucho más complejas, poniendo más lógica en el nivel de transacción en lugar de, por ejemplo, un contrato inteligente.

 

Esta es la gran ventaja de usar Sawtooth: es un marco para escribir su propio sabor de una cadena de bloques, donde la lógica se puede impulsar directamente en la transacción y no, necesariamente, en los contratos inteligentes. Como ejemplo de esta flexibilidad, puede consultar este repositorio donde se describe un procesador de transacciones que manejará un juego de tres en raya.

La interacción con la cadena de bloques tiene solo dos métodos, write_datay read_dataambos interactuarán con la cadena de bloques operando a través de la API REST (ver el bloque en el diagrama de arriba). La lectura de la cadena de bloques es bastante sencilla; es solo la invocación de la API /estado con la dirección desde la que leer.

 

Escribir en la cadena de bloques, por otro lado, consiste en una secuencia específica de pasos. Puedes seguirlos en el interact.jsarchivo:

  1. Primero, se crea el encabezado de la transacción que, lo más importante, contendrá la familia de transacciones. Es decir, el procesador de transacciones que se invocará para manejar nuestra transacción (líneas 48–58). En segundo lugar, la transacción se firma (líneas 61 a 66) utilizando la clave privada del sujeto que la envía;
  2. Las transacciones se recopilan dentro de un lote, un lote puede recopilar transacciones provenientes de diferentes sujetos y se firma en sí mismo (líneas 69 a 81);
  3. Una vez que el lote de transacciones firmado está listo, se codifica (líneas 84 a 86) para poder usarlo de forma segura en la invocación de la API (líneas 89 a 93).

Cambiar el algoritmo de consenso

Después de inspeccionar el código fuente, echemos un vistazo al archivo compuesto por Docker llamado single-node.yaml. Contiene exactamente los cinco componentes descritos anteriormente:

  1. El procesador de transacciones cuya lógica se describe en el processor.jsarchivo;
  2. La API REST de Sawtooth que solo especificará en qué puerto se vinculará;
  3. El procesador de transacciones de configuración obligatoria que permite interactuar con la configuración guardada en la cadena de bloques;
  4. El validador describe la configuración del nodo validador. Como es de esperar, aquí es donde se especifica el algoritmo de consenso (línea 48). En esta versión, se especifica que usaremos el algoritmo del modo dev;
  5. El motor devmode contiene las (pocas) configuraciones de este algoritmo específico

Cambiar el algoritmo de consenso es bastante simple: simplemente modifique la configuración del nodo de validación eligiendo el algoritmo que pretende usar. En aras de la claridad, hemos utilizado el motor de modo de desarrollo, que funciona cómodamente con un solo nodo; los algoritmos más complejos necesitan al menos cuatro nodos y, coherentemente, el archivo docker-compose es más complejo.

Como ejemplo, verifique el GitHub que contiene las configuraciones para usar pBFT como un algoritmo de consenso (línea 138) y cómo se configura dicho algoritmo para su uso en este escenario (líneas 300–304); pBFT necesita al menos cuatro nodos para funcionar (debido a la elección del líder), por lo que encontrará cuatro nodos validadores y, análogamente, cuatro motores pBFT, uno para cada validador.

Conclusión

Hyperledger Sawtooth es capaz de acomodar una amplia gama de diferentes configuraciones de blockchain, lo que nos permite personalizar la forma y los medios de las transacciones. El algoritmo de consenso, que es central en la forma en que la cadena de bloques realmente se comporta, es configurable y, listo para usar, hay una variedad de opciones disponibles para seleccionar cuidadosamente el rendimiento de la cadena de bloques y la resistencia a los ataques bizantinos.

Fuente: https://blog.logrocket.com/hyperledger-sawtooth-introduction/ 

#hyperledger #sawtooth 

Una Suave introducción A Hyperledger Sawtooth
Saul  Alaniz

Saul Alaniz

1647353400

Desarrollar Contratos inteligentes De Blockchain Autorizados

 Hyperledger es un proyecto general de la Fundación Linux que proporciona un libro mayor distribuido, implementaciones de cadena de bloques de código abierto y las herramientas asociadas, como marcos de libros mayores distribuidos, motores de contratos inteligentes, bibliotecas de clientes, interfaces gráficas, bibliotecas de utilidades y aplicaciones de muestra.

Una cadena de bloques es un libro mayor de transacciones distribuido entre pares que se forja por consenso, combinado con un sistema para contratos inteligentes y otras tecnologías de asistencia. Estas transacciones se duplican y distribuyen en toda la red de sistemas informáticos participantes en la cadena de bloques. En otras palabras, una cadena de bloques es un sistema operativo legalmente cumplido de mercados, redes de intercambio de datos, micro monedas y comunidades digitales descentralizadas.

Hyperledger Fabric es una infraestructura de cadena de bloques autorizada destinada principalmente a proyectos de integración en los que se requiere una tecnología de contabilidad distribuida (DLT). No ofrece servicios para el usuario que no sean un SDK para Node.js, JavaScript y Go. Proporciona arquitectura modular entre nodos, ejecución de contratos inteligentes y servicios configurables de consenso y membresía.

En este artículo, crearemos nuestra primera aplicación de cadena de bloques autorizada, exploraremos los contratos inteligentes y discutiremos algunas características importantes de Hyperledger Fabric. ¡Empecemos!

Acerca de Hyperledger Fabric

Una red Hyperledger Fabric se compone de tres componentes principales.

Los nodos pares ejecutan código de cadena, acceden a datos contables, respaldan transacciones e interactúan con aplicaciones. Los nodos de pares se pueden iniciar, detener, reconfigurar y eliminar en cualquier punto del ciclo de vida de la cadena de bloques.

Los nodos de pedido aseguran la consistencia de la cadena de bloques y entregan las transacciones respaldadas a los pares de la red. Un nodo de pedido es responsable de ordenar transacciones, formar el servicio de pedidos, empaquetar transacciones en bloques y distribuir estos bloques para anclar pares en toda la red.

Los nodos del proveedor de servicios de membresía (MSP) generalmente se implementan como una autoridad de certificación, que administra los certificados X.509 y se utilizan para autenticar la identidad y las funciones de los miembros. Los nodos de MSP son la capa de abstracción para todos los mecanismos y protocolos criptográficos detrás de la emisión de certificados, la validación de certificados y la autenticación de usuarios.

Interconexión entre nodos pares, contrato inteligente, libro mayor y red blockchain

En Hyperledger Fabric, puede usar diferentes algoritmos de consenso, sin embargo, la tolerancia práctica a fallas bizantinas (PBFT) es la más utilizada.

Funcionalidades

Hyperledger Fabric tiene cinco funcionalidades principales.

Gestión de identidad

Para las redes autorizadas, el servicio de identidad de membresía administra las identificaciones de los usuarios, autenticando a los participantes en la red blockchain. Además, los desarrolladores pueden habilitar y limitar operaciones de red específicas a través de capas adicionales utilizando listas de control de acceso. Por ejemplo, se podría permitir que un ID de usuario específico invoque una aplicación de código de cadena, pero que no pueda implementar un nuevo código de cadena.

Procesamiento eficiente

Para proporcionar simultaneidad y paralelismo a la red, Hyperledger Fabric incluye ordenación de transacciones, por ejemplo, por tipos de autoridades de nodo. Los desarrolladores pueden realizar múltiples transacciones por el mismo nodo y asignar roles de red por tipo de nodo.

Diseño modular

Hyperledger Fabric implementa una arquitectura modular para brindar opciones funcionales a los diseñadores de redes, por ejemplo, a través de la disponibilidad de diferentes algoritmos criptográficos, algoritmos o identidad, cifrado, ordenación y cifrado, lo que permite un diseño universal.

Privacidad y confidencialidad

Hyperledger Fabric permite que las empresas competidoras o cualquier grupo que requiera transacciones privadas y confidenciales coexistan en la misma red autorizada. Admite funciones como rutas de mensajería restringidas para subconjuntos específicos de miembros de la red. Por ejemplo, los datos que incluyen transacciones, miembros e información del canal son invisibles e inaccesibles para los miembros de la red a los que no se les ha otorgado acceso explícitamente.

Funcionalidad de código de cadena

La lógica de codificación es invocada por tipos específicos de transacciones en el canal, por ejemplo, código de cadena del sistema, código de cadena del sistema de configuración y ciclo de vida, y código de cadena del sistema de aprobación y validación.

Arquitectura de Hyperledger Fabric

Ahora que estamos familiarizados con las funcionalidades de Hyperledger Fabric, revisemos los componentes que lo componen.

Nodo

En Hyperledger Fabric, cualquier dispositivo informático que se comunique en la red se denomina nodo.

Cliente

Un cliente es un nodo que puede actuar en nombre de los usuarios finales.

Mirar

Hyperledger Fabric tiene una red peer-to-peer en la que un nodo peer es responsable del estado del libro mayor y de la optimización del rendimiento. Los compañeros son de dos tipos. Por un lado, los endosantes simulan y endosan transacciones. Un endoso de transacción es una respuesta firmada a los resultados de la transacción simulada. Por otro lado, los encargados de la confirmación verifican los endosos y validan los resultados de las transacciones antes de confirmar las transacciones en la cadena de bloques.

Actas

Las transacciones de Hyperledger Fabric son de dos tipos. Las transacciones de implementación crean un nuevo código de cadena con un parámetro como un programa e instalan el código de cadena en la cadena de bloques. Las transacciones de invocación se ejecutan en el contexto de un código de cadena anterior o una implementación de contrato inteligente.

Estructuras de datos

Key-Value Store (KVS) es la estructura de datos básica de la cadena de bloques. A menudo, las claves son nombres y el valor son blobs. KVS admite dos operaciones PUTy GET. La estructura de datos se toma como un estado en un momento dado. La base de datos de estado predeterminada, LevelDB, se puede reemplazar con CouchDB .

Libro mayor

En lo que se conoce como bloques de transacciones hashchain ordenados, los cambios de estado se almacenan en orden de ocurrencia, lo que facilita la referencia posterior. La cadena de bloques registra las transacciones dentro del libro mayor. Un libro mayor contiene bloques ordenados, que contienen una matriz de transacciones ordenada. Un libro mayor almacena cada cambio de estado, ya sea exitoso o fallido.

Base de datos de telas

En Hyperledger Fabric, los datos se almacenan en dos lugares, la base de datos estatal y la base de datos del libro mayor.

Los datos del estado actual representan los valores más recientes de todos los activos en el libro mayor. Dado que el estado actual representa todas las transacciones comprometidas en el canal, a veces se lo denomina estado mundial.

La base de datos del libro mayor almacena bloques serializados donde cada bloque tiene una o más transacciones. Cada transacción contiene un conjunto de lectura y escritura, que modifica uno o más pares clave/valor. El libro mayor es la fuente definitiva de datos y es inmutable.

Mecanismos de pedido

Hyperledger Fabric proporciona tres mecanismos de pedido.

El mecanismo de ordenación SOLO, que implica un único nodo de ordenación, lo suelen utilizar los desarrolladores que experimentan con redes Hyperledger Fabric.

El mecanismo de pedidos de Kafka se recomienda para uso en producción. Los datos consisten en transacciones endosadas y conjuntos RW. Debido a que usa Apache Kafka, este tipo de ordenamiento es tolerante a fallas.

Por último, el mecanismo de ordenamiento de Tolerancia a fallas bizantinas simplificada es tolerante a fallas bizantinas y fallas, lo que significa que puede llegar a un acuerdo incluso en presencia de nodos maliciosos o defectuosos.

Consenso

En un sistema de libro mayor distribuido, el consenso es el proceso de llegar a un acuerdo sobre el siguiente conjunto de transacciones que se agregará al libro mayor. Hyperledger Fabric se compone de tres pasos distintos.

Primero, en el paso de respaldo de la transacción, un par que respalda ejecuta el código de cadena que, si tiene éxito, produce una transacción real para el libro mayor. Luego, el par que respalda firma la transacción y la devuelve al proponente.

El servicio de pedidos admite pedidos estrictos, lo que significa que si la Transacción T1ya se ha escrito dentro del bloque B1, entonces la misma transacción T1no se puede volver a escribir en diferentes bloques como B2o B3. Por último, la validación y el compromiso incluyen la validación de transacciones y el compromiso del libro mayor.

Contratos inteligentes

Un contrato inteligente define la lógica de transacción que controla el ciclo de vida de un objeto comercial contenido en el estado global. En Hyperledger Fabric, la ejecución de contratos inteligentes se denomina código de cadena. Los usuarios de Hyperledger Fabric a menudo usan los términos contrato inteligente y código de cadena indistintamente.

Los contratos inteligentes de Hyperledger Fabric también se denominan código de cadena y están escritos en Go. El código de cadena sirve como lógica comercial para una red de Hyperledger Fabric, y el contrato inteligente indica cómo los nodos involucrados manipulan los activos dentro de la red.

Cómo interactúan las aplicaciones con la red

En Hyperledger Fabric, los contratos inteligentes y el código de cadena se alojan en la red, identificados por nombre y versión. Para ejecutar códigos de cadena o contratos inteligentes, las aplicaciones usan las API del SDK que implementa el SDK.

Hyperledger Fabric tiene tres opciones para que los desarrolladores creen aplicaciones, el SDK de Node.js, el SDK de Java y la CLI. Además, Hyperledger proporciona muestras de Hyperledger Fabric para que los usuarios exploren las funciones de Hyperledger Fabric.

Desarrollo de una aplicación de cadena de bloques autorizada

Ahora que entendemos la arquitectura de Hyperledger Fabric, creemos una aplicación de cadena de bloques autorizada. Primero, aclaremos los pasos principales que seguiremos al desarrollar nuestra aplicación Hyperledger Fabric.

Primero, debemos configurar el entorno de desarrollo, incluidas las instalaciones para la red donde se ejecutará nuestro contrato inteligente. A continuación, debemos comprender el SDK de Node.js y la programación central detrás de nuestra aplicación. Hyperledger Fabric ofrece varios SDK, como Go, JavaScript y Java. En este tutorial, trabajaremos con un poco de Go y mucho JavaScript.

Además, necesitamos comprender ejemplos de contratos inteligentes, incluidas las transacciones. Ejecutaremos consultas simuladas por aplicaciones y también actualizaremos el libro mayor. Por último, desarrollaremos una aplicación de cadena de bloques de muestra utilizando nuestro contrato inteligente.

Configurar un entorno de desarrollo

requisitos previos

Para configurar un entorno de desarrollo con Hyperledger Fabric, necesitaremos lo siguiente

  1. La última versión de cURL
  2. Docker y Docker Compose ≥v17.06.2-ce
  3. Ir v1.12.x
  4. Node.js ≥v8.9 o ≥v10.15.3

Instalaciones

En nuestro ejemplo, usaremos distribuciones basadas en Linux Ubuntu 20.04 y 18.04. Primero, actualice su máquina actual con sudo apt-get update. Luego, instalaremos cURL con sudo apt instal curly verificaremos la versión de cURL con curl --version, como se ve a continuación:

 curl --version
curl 7.68.0 (x86_64-pc-linux-gnu) libcurl/7.68.0 OpenSSL/1.1.1f zlib/1.2.11 brotli/1.0.7 libidn2/2.2.0 libpsl/0.21.0 (+libidn2/2.2.0) libssh/0.9.3/openssl/zlib nghttp2/1.40.0 librtmp/2.3
Release-Date: 2020-01-08
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp 
Features: AsynchDNS brotli GSS-API HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets

Estibador

Tendremos que instalar los paquetes de Docker requeridos de la siguiente manera:

sudo apt-get install apt-transport-https ca-certificates gnupg-agent software-properties-common

A continuación, agregaremos la clave GPG oficial de Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -Check OK

Para configurar Docker, ejecute el siguiente código:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu  $(lsb_release -cs)  stable"

Instale Docker con el siguiente código:

sudo apt-get install docker-ce docker-ce-cli containerd.io`

Comprobaremos la versión de Docker con docker --versionel siguiente fragmento de código:

logrocket:~$ docker --version
Docker version 20.10.12, build e91ed57

A continuación, probaremos la ejecución del motor Docker:

docker run hello-world

Componer ventana acoplable

Para descargar la última versión de Docker Compose, ejecute el siguiente código:

sudo curl -L "https://github.com/docker/compose/releases/download/1.25.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Cambie los permisos a ejecutable con sudo chmod +x /usr/local/bin/docker-compose. Para verificar la versión de Docker Compose, ejecute docker-compose --versionlo siguiente:

logrocket:~$ docker-compose --version
docker-compose version 1.25.5, build 8a1c60f6

Ir

Descarga el tararchivo:

curl -O https://storage.googleapis.com/golang/go1.12.9.linux-amd64.tar.gz

Mueva el directorio Ir:

sudo mv go1.12.9.linux-amd64.tar.gz /usr/local/

Extraiga el tararchivo con el siguiente código:

sudo tar -xvzpf /usr/local/go1.12.9.linux-amd64.tar.gz

Puede eliminar el tararchivo con el siguiente código:

sudo rm -rf /usr/local/go1.12.9.linux-amd64.tar.gz

Variables de entorno

Abra el perfil con vim .profiley agregue la PATHvariable al final del .profilearchivo:

export GOPATH=$HOME/go
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin

Navegue hasta el perfil de origen con source ~/.profiley verifique la versión actual de Go con el siguiente código:

logrocket:~$ go version
go version go1.12.9 linux/amd64

Nodo.js

Ejecute el siguiente código para obtener Node.js v10.x:

curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -`

Instale Node.js con el siguiente comando:

sudo apt-get install -y nodejs

Para verificar la versión actual de Node.js, ejecute el siguiente código:

nodejs --version
logrocket:~$ nodejs --version
v10.19.0

Ahora, verifique la versión npm con npm -v:

logrocket:~$ npm -v
6.14.4

Tela de hiperlibro

Cree un nuevo directorio ejecutando el siguiente código:

mkdir hyperledger-fabric && cd hyperledger-fabric

Agregar permisos de Docker:

sudo usermod -aG docker $USER

Verifique los permisos y actualice la terminal:

logrocket:~$ id -nG
tapasweni adm cdrom sudo dip plugdev lpadmin lxd sambashare
newgrp docker

Descargar Fabric v1.4.7:

curl -sSL https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh  | bash -s -- 1.4.7 1.4.7 0.4.20


logrocket:~$ curl -sSL https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh  | bash -s -- 1.4.7 1.4.7 0.4.20

Clone hyperledger/fabric-samples repo

===> Cloning hyperledger/fabric-samples repo
Cloning into 'fabric-samples'...
remote: Enumerating objects: 9165, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 9165 (delta 0), reused 1 (delta 0), pack-reused 9164
Receiving objects: 100% (9165/9165), 5.21 MiB | 3.71 MiB/s, done.
Resolving deltas: 100% (4898/4898), done.
===> Checking out v1.4.7 of hyperledger/fabric-samples

Pull Hyperledger Fabric binaries

===> Downloading version 1.4.7 platform specific fabric binaries
===> Downloading:  https://github.com/hyperledger/fabric/releases/download/v1.4.7/hyperledger-fabric-linux-amd64-1.4.7.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   680  100   680    0     0   1683      0 --:--:-- --:--:-- --:--:--  1679
100 79.3M  100 79.3M    0     0  4614k      0  0:00:17  0:00:17 --:--:-- 4762k
==> Done.
===> Downloading version 1.4.7 platform specific fabric-ca-client binary
===> Downloading:  https://github.com/hyperledger/fabric-ca/releases/download/v1.4.7/hyperledger-fabric-ca-linux-amd64-1.4.7.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   683  100   683    0     0   1876      0 --:--:-- --:--:-- --:--:--  1876
100 23.6M  100 23.6M    0     0  3962k      0  0:00:06  0:00:06 --:--:-- 4904k
==> Done.

Pull Hyperledger Fabric docker images

FABRIC_IMAGES: peer orderer ccenv tools
===> Pulling fabric Images
====> hyperledger/fabric-peer:1.4.7
1.4.7: Pulling from hyperledger/fabric-peer
Digest: sha256:a395036c83125ccf3820eb1752ac9ba8017e4432768b59d658bfba91a311d154
Status: Image is up to date for hyperledger/fabric-peer:1.4.7
docker.io/hyperledger/fabric-peer:1.4.7
====> hyperledger/fabric-orderer:1.4.7
1.4.7: Pulling from hyperledger/fabric-orderer
Digest: sha256:aef31580eee468e08eb8354bb5f2ec23e0fc12f9b638bd41d207dd5e4d6c6e60
Status: Image is up to date for hyperledger/fabric-orderer:1.4.7
docker.io/hyperledger/fabric-orderer:1.4.7
====> hyperledger/fabric-ccenv:1.4.7
1.4.7: Pulling from hyperledger/fabric-ccenv
Digest: sha256:11dbbdce7f3f789d7bbc758b593005e9aeccd991ed64a3f296e824aaf67f07c6
Status: Image is up to date for hyperledger/fabric-ccenv:1.4.7
docker.io/hyperledger/fabric-ccenv:1.4.7
====> hyperledger/fabric-tools:1.4.7
1.4.7: Pulling from hyperledger/fabric-tools
Digest: sha256:59328549b3384f565cb5bd19b74c977820781e4709158666ead74fcd970c11e1
Status: Image is up to date for hyperledger/fabric-tools:1.4.7
docker.io/hyperledger/fabric-tools:1.4.7
===> Pulling fabric ca Image
====> hyperledger/fabric-ca:1.4.7
1.4.7: Pulling from hyperledger/fabric-ca
Digest: sha256:9418ea351bfbef4bf2bca34bcd77305bdb9a45d2c1aab3237c08c17da0b4d1dd
Status: Image is up to date for hyperledger/fabric-ca:1.4.7
docker.io/hyperledger/fabric-ca:1.4.7
===> List out hyperledger docker images
hyperledger/fabric-ca        1.4            743a758fae29   19 months ago   154MB
hyperledger/fabric-ca        1.4.7          743a758fae29   19 months ago   154MB
hyperledger/fabric-ca        latest         743a758fae29   19 months ago   154MB
hyperledger/fabric-tools     1.4            a026b435e575   19 months ago   1.49GB
hyperledger/fabric-tools     1.4.7          a026b435e575   19 months ago   1.49GB
hyperledger/fabric-tools     latest         a026b435e575   19 months ago   1.49GB
hyperledger/fabric-ccenv     1.4            c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-ccenv     1.4.7          c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-ccenv     latest         c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-orderer   1.4            df155b01ed80   19 months ago   123MB
hyperledger/fabric-orderer   1.4.7          df155b01ed80   19 months ago   123MB
hyperledger/fabric-orderer   latest         df155b01ed80   19 months ago   123MB
hyperledger/fabric-peer      1.4            5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-peer      1.4.7          5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-peer      latest         5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-baseos    amd64-0.4.20   121a92cc3fc0   22 months ago   85MB
logrocket:~$ cURL hyperledger/fabric-samples

Ahora, actualice las variables de entorno:

vim .profile
export PATH=/home/$USER/hyperledger/fabric-samples/bin:$PATH
source ~/.profile

Ejecutar Hyperledger Fabric

Ir adentro fabric-samples/first-network:

Primer directorio de red de Hyperledger Fabric

Traiga la red con ./byfn.sh up:

logrocket:~$ cd first-network/
logrocket:~$ ls
base               channel-artifacts     connection-org2.yaml    docker-compose-cli.yaml           docker-compose-kafka.yaml  scripts
byfn.sh            configtx.yaml         connection-org3.json    docker-compose-couch-org3.yaml    docker-compose-org3.yaml
ccp-generate.sh    connection-org1.json  connection-org3.yaml    docker-compose-couch.yaml         eyfn.sh
ccp-template.json  connection-org1.yaml  crypto-config.yaml      docker-compose-e2e-template.yaml  org3-artifacts
ccp-template.yaml  connection-org2.json  docker-compose-ca.yaml  docker-compose-etcdraft2.yaml     README.md
logrocket:~$ ./byfn.sh -m up
Starting for channel 'mychannel' with CLI timeout of '10' seconds and CLI delay of '3' seconds
Continue? [Y/n] 
proceeding ...
LOCAL_VERSION=1.4.7
DOCKER_IMAGE_VERSION=1.4.7
/home/tapasweni/hyperledger/fabric-samples/first-network/../bin/cryptogen

##########################################################
##### Generate certificates using cryptogen tool #########
##########################################################
+ cryptogen generate --config=./crypto-config.yaml
org1.example.com
org2.example.com
+ res=0
+ set +x

Generate CCP files for Org1 and Org2
/home/tapasweni/hyperledger/fabric-samples/first-network/../bin/configtxgen
##########################################################
#########  Generating Orderer Genesis block ##############
##########################################################
CONSENSUS_TYPE=solo
+ '[' solo == solo ']'
+ configtxgen -profile TwoOrgsOrdererGenesis -channelID byfn-sys-channel -outputBlock ./channel-artifacts/genesis.block
2021-12-31 17:52:52.853 IST [common.tools.configtxgen] main -> INFO 001 Loading configuration
2021-12-31 17:52:53.051 IST [common.tools.configtxgen.localconfig] completeInitialization -> INFO 002 orderer type: solo
2021-12-31 17:52:53.051 IST [common.tools.configtxgen.localconfig] Load -> INFO 003 Loaded configuration: /home/tapasweni/hyperledger/fabric-samples/first-network/configtx.yaml

Verifique Docker con docker ps -a:

logrocket:~$ docker ps -a
CONTAINER ID   IMAGE                                                                                                  COMMAND                  CREATED              STATUS              PORTS                                           NAMES
ef86361332c7   dev-peer1.org2.example.com-mycc-1.0-26c2ef32838554aac4f7ad6f100aca865e87959c9a126e86d764c8d01f8346ab   "chaincode -peer.add…"   About a minute ago   Up About a minute                                                   dev-peer1.org2.example.com-mycc-1.0
c9008d040273   dev-peer0.org1.example.com-mycc-1.0-384f11f484b9302df90b453200cfb25174305fce8f53f4e94d45ee3b6cab0ce9   "chaincode -peer.add…"   2 minutes ago        Up 2 minutes                                                        dev-peer0.org1.example.com-mycc-1.0
9ad7861a975c   dev-peer0.org2.example.com-mycc-1.0-15b571b3ce849066b7ec74497da3b27e54e0df1345daff3951b94245ce09c42b   "chaincode -peer.add…"   4 minutes ago        Up 4 minutes                                                        dev-peer0.org2.example.com-mycc-1.0
91ce4e6cfaf5   hyperledger/fabric-tools:latest                                                                        "/bin/bash"              5 minutes ago        Up 5 minutes                                                        cli
c4e3238a2301   hyperledger/fabric-orderer:latest                                                                      "orderer"                6 minutes ago        Up 5 minutes        0.0.0.0:7050->7050/tcp, :::7050->7050/tcp       orderer.example.com
416a0f98cb6b   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:10051->10051/tcp, :::10051->10051/tcp   peer1.org2.example.com
84e42d29fab9   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:7051->7051/tcp, :::7051->7051/tcp       peer0.org1.example.com
7ad2e6e34292   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:8051->8051/tcp, :::8051->8051/tcp       peer1.org1.example.com
9ff94883cacf   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:9051->9051/tcp, :::9051->9051/tcp       peer0.org2.example.com
logrocket:~$ 

Baja la red con ./byfn.sh down:

logrocket:~$ ./byfn.sh -m down
Stopping for channel 'mychannel' with CLI timeout of '10' seconds and CLI delay of '3' seconds
Continue? [Y/n] 
proceeding ...
WARNING: The BYFN_CA1_PRIVATE_KEY variable is not set. Defaulting to a blank string.
WARNING: The BYFN_CA2_PRIVATE_KEY variable is not set. Defaulting to a blank string.
Stopping cli                    ... done
Stopping peer0.org2.example.com ... done
Stopping peer0.org1.example.com ... done
Stopping peer1.org2.example.com ... done
Stopping peer1.org1.example.com ... done
Stopping orderer.example.com    ... done
Removing cli                    ... done
Removing peer0.org2.example.com ... done
Removing peer0.org1.example.com ... done
Removing peer1.org2.example.com ... done
Removing peer1.org1.example.com ... done
Removing orderer.example.com    ... done
Removing network net_byfn
Removing volume net_orderer.example.com
Removing volume net_peer0.org1.example.com
Removing volume net_peer1.org1.example.com
Removing volume net_peer0.org2.example.com
Removing volume net_peer1.org2.example.com
Removing volume net_orderer2.example.com
WARNING: Volume net_orderer2.example.com not found.
Removing volume net_orderer3.example.com
WARNING: Volume net_orderer3.example.com not found.
Removing volume net_orderer4.example.com
WARNING: Volume net_orderer4.example.com not found.
Removing volume net_orderer5.example.com
WARNING: Volume net_orderer5.example.com not found.
Removing volume net_peer0.org3.example.com
WARNING: Volume net_peer0.org3.example.com not found.
Removing volume net_peer1.org3.example.com
WARNING: Volume net_peer1.org3.example.com not found.
1c1c3bd27578
052b542e408f
2371102e3fa1
Untagged: dev-peer1.org2.example.com-mycc-1.0-26c2ef32838554aac4f7ad6f100aca865e87959c9a126e86d764c8d01f8346ab:latest
Deleted: sha256:574b46ed09496b052b9963d79362fa3e15d5430d6f7e227c8edccfe37a94a54d
Deleted: sha256:89856e5feb7feafde31a15decf9d2657f7344e38ee90bc8e73f7c0e189a0422c
Deleted: sha256:570373df622999f59a978635db23a4ce6f6f3c6b1067aeafd3d2a64b4b1020b0
Deleted: sha256:31ce9090622db38830dfdc3209c4044d70f7345e863fcd54c40ac2d2a2abbf03
Untagged: dev-peer0.org1.example.com-mycc-1.0-384f11f484b9302df90b453200cfb25174305fce8f53f4e94d45ee3b6cab0ce9:latest
Deleted: sha256:c40d025bb22f74cfa14568a70257964d94b557e23811c9bfb5d4591200f64b62
Deleted: sha256:b9e1d83750424813abf0fe6f96fbc3904680bf0ae23474b4939e60596b77f1d9
Deleted: sha256:a5dc79ea636789a36962fcac872a77a86235f95fa9f3714c8bd8da42237b51f3
Deleted: sha256:8b9a4e82ec7825be4e6f52b7192c2b76fc5ab671a871dcc9c3423f23713009da
Untagged: dev-peer0.org2.example.com-mycc-1.0-15b571b3ce849066b7ec74497da3b27e54e0df1345daff3951b94245ce09c42b:latest
Deleted: sha256:599b2ad18745375616a97b3a99411571aeb456b0c320f853bdd9d15d19a5c875
Deleted: sha256:65a03c40d4a982f5b6589a8fd2e6aac66b70a295d68b3c8892a8fe5bf41f3edc
Deleted: sha256:ab76526d7091a8511de05ae2c91f0279f10aa0b07ad4a62c5cc105c454d79894
Deleted: sha256:6d5781813eb41dfc57917af52d5c4e7234864d005b8d38c07f51a759fa8790f0
logrocket:~$

Crear un canal llamado mychannelcon ./network.sh up createChannel:

    ========= Channel successfully joined ===========

Hyperledger Fabric Node.js SDK

Este tutorial usa el SDK de Hyperledger Node.js , que usaremos para interactuar con la red e implementar contratos inteligentes en la red, el libro mayor y la API.

SDK

Para interactuar con el cliente de red Fabric, usamos Fabric-CA Client , que se encuentra bajo el paraguas de Fabric CA. El componente Fabric CA permite que las aplicaciones inscriban a pares y usuarios de aplicaciones para establecer identidades confiables en la red blockchain. También brinda soporte para envíos de transacciones con seudónimos con Certificados de transacciones.

El paquete Fabric Common encapsula el código común utilizado por todos los paquetes fabric-sdk-node, lo que admite interacciones detalladas con la red Fabric para enviar invocaciones de transacciones.

fabric-network es responsable de establecer una conexión con la red blockchain de Fabric. Este paquete encapsula las API para conectarse a una red de Fabric, enviar transacciones y realizar consultas en el libro mayor a un nivel de abstracción más alto que a través de Fabric Common.

Por último, el paquete fabric-protos encapsula los protobúferes que se usan para comunicarse a través de gRPC.

Instalación de API

Instale la API de red:

npm install fabric-network

Instale la API del cliente:

npm install fabric-ca-client

Instale la API común:

npm install fabric-common

Instale la API de protobúferes:

npm install fabric-protos

Primeros pasos con el SDK

La clase Gateway es el punto de entrada que se utiliza para interactuar con una red blockchain de Hyperledger Fabric y lo primero que se inicia. El objeto de larga duración proporciona una conexión reutilizable a un par dentro de la red blockchain de Fabric, lo que permite el acceso a cualquiera de las redes o canales de blockchain de los que ese par en particular es miembro.

A continuación, obtendremos acceso al contrato inteligente/código de cadena que se ejecuta e implementa dentro de esa red de cadena de bloques. Las transacciones se activan y las consultas se evalúan en esta red de cadena de bloques.

Mediante el uso de escuchas de eventos de contratos inteligentes, las aplicaciones cliente pueden iniciar acciones o procesos comerciales en respuesta a eventos de código de cadena emitidos por transacciones de contratos inteligentes. Todas las actualizaciones del libro mayor se pueden observar mediante detectores de eventos de bloque.

API de código de cadena clave

ChaincodeStub proporciona funciones que permiten a los desarrolladores interactuar con el libro mayor subyacente para consultar, actualizar y eliminar activos:

func (stub *ChaincodeStub) GetState(key string) ([]byte, error)

El código anterior devuelve el valor de la clave especificada del libro mayor. Si la clave no existe en la base de datos de estado, nil, nilse devuelve:

func (stub *ChaincodeStub) PutState(key string, value []byte) error 

El código anterior coloca la clave y el valor especificados en la transacción y los escribe como una propuesta de escritura de datos. PutStateno afecta el libro mayor hasta que la transacción se valida y se confirma con éxito:

func (stub *ChaincodeStub) DelState(key string) error

El código anterior registra la clave especificada que se eliminará en el Writeconjunto de la propuesta de transacción. Cuando la transacción se valida y se compromete con éxito, la clave y su valor se eliminarán del libro mayor.

fabric-contract-apiproporciona la interfaz de contrato donde escribimos la lógica comercial en palabras técnicas para nuestros contratos inteligentes o código de cadena.

La CommercialPaperContract extends Contract {...}clase contiene las definiciones de transacción para papel comercial, emisión, compra y canje.

Debe crear tanto un método Initcomo un Invokemétodo dentro de su código de cadena. Antes de que se pueda invocar el código de cadena, se debe instalar e instanciar el código de cadena utilizando el código de cadena instally los instantiatecomandos del mismo nivel, respectivamente.

Hasta ahora, esto completa nuestra comprensión de Hyperledger Fabric, su arquitectura, configuración, características y SDK. En la siguiente parte del artículo, instalaremos nuestra aplicación y exploraremos más sobre los contratos inteligentes.

Comprender ejemplos de contratos inteligentes

En Hyperledger Fabric, la lógica y las reglas comerciales principales se definen mediante contratos inteligentes o código de cadena. Los usuarios finales interactúan con la red de la cadena de bloques y el libro mayor de la cadena de bloques llamando a las reglas definidas de un contrato inteligente, invocando contratos inteligentes o código de cadena.

Supongamos que el usuario U ha implementado un contrato inteligente SC. Cualquiera que quiera participar, ya sea una organización o un grupo, debe validar las transacciones o consultar el libro mayor de blockchain, lo que se puede lograr instalando el código de cadena en sus pares.

Después de instalar o implementar el contrato inteligente o el código de cadena, los compañeros se unen al canal. Luego, los miembros del canal pueden implementar el código de cadena en el canal y usar la lógica o las reglas comerciales del contrato inteligente en el código de cadena para crear o actualizar activos en el libro mayor del canal.

Hasta ahora, ya hemos creado con éxito el canal. No utilizaremos la CLI de pares proporcionada por Hyperledger Fabric para implementar el código de cadena del assets-transferpaquete en el canal. En cambio, primero, empaquetemos el contrato inteligente. Para ser instalado en cualquier máquina participante, el código de cadena debe estar empaquetado en el .tar.gzarchivo. En otras palabras, un par que es una unidad participante en la red puede interactuar con otras máquinas y dispositivos informáticos en la red blockchain.

A continuación, instalamos el paquete chaincode, que debe instalarse en todos los pares de la organización participante para seguir las reglas o la lógica comercial de los demás. Antes de participar con esta organización en la red blockchain, un cierto umbral de pares que forman parte de la organización debe aprobar la definición del código de cadena. Finalmente, para invocar aún más la lógica comercial o las reglas establecidas para la interacción, cada canal debe tener comprometido el código de cadena.

Paquete contrato inteligente

Revisemos nuestro código de cadena JavaScript de muestra. En fabric-samples, accederá a la versión Go básica del código de cadena de transferencia de activos con cd fabric-samples/asset-transfer-basic/chaincode-javascript.

El ejemplo usa módulos de nodo para instalar e implementar el código de cadena. package.jsondescribe las dependencias requeridas para empaquetar e instalar nuestro código de cadena. Si has entendido bien la primera parte, estas dependencias te resultarán familiares:

$ cat package.json

"dependencies": {
        "fabric-contract-api": "^2.0.0",
        "fabric-shim": "^2.0.0"

Revisemos el fabric-contract-apide nuestro contrato inteligente de muestra:

const { Contract } = require('fabric-contract-api');

class AssetTransfer extends Contract {
    ...
}

El código anterior habilitará las operaciones CRUD básicas en nuestro libro mayor, o en otras palabras, leer y escribir en el libro mayor de la cadena de bloques usando diferentes llamadas a funciones:

async CreateAsset(ctx, id, color, size, owner, appraisedValue) {
        const asset = {
            ID: id,
            Color: color,
            Size: size,
            Owner: owner,
            AppraisedValue: appraisedValue,
        };

        await ctx.stub.putState(id, Buffer.from(JSON.stringify(asset)));
    }

 

Dentro de este directorio, ejecute npm installpara instalar las dependencias requeridas por nuestro paquete chaincode antes de instalar o implementar chaincode en el libro mayor. Para crear un paquete de código de cadena, vaya a test-networky configure las rutas de configuración de la siguiente manera:

cd ../../test-network
export PATH=${PWD}/../bin:$PATH
export FABRIC_CFG_PATH=$PWD/../config/

Ejecute peer versionpara asegurarse de que puede interactuar con la CLI del mismo nivel:

logrocket:~$ peer version
peer:
 Version: 1.4.7
 Commit SHA: e0afaa741
 Go version: go1.13.9
 OS/Arch: linux/amd64
 Chaincode:
  Base Image Version: 0.4.20
  Base Docker Namespace: hyperledger
  Base Docker Label: org.hyperledger.fabric
  Docker Namespace: hyperledger

Empaquetamos nuestro código de cadena usando el siguiente comando:

peer lifecycle chaincode package basic.tar.gz --path ../asset-transfer-basic/chaincode-javascript/ --lang node --label basic_1.0

Ahora, puede instalar el  basic.tar.gzarchivo en la red de su elección. Su código de cadena o contrato inteligente está listo para instalarse, establecer interacciones con el libro mayor y eventualmente convertirse en uno de ellos al cumplir con el contrato inteligente.

Instalar el paquete de código de cadena

Instalemos el contrato inteligente/código de cadena de transferencia de activos básico y empaquetado en nuestros pares. Piense en nuestro usuario Uy contrato inteligente SC. Vamos a crear dos organizaciones, Org1y Org2. Como en nuestro ejemplo, ambas organizaciones requieren respaldos mutuos, por lo que se instalará chaincode en todos los pares operados por ambas organizaciones:

peer0.org1.example.com
peer0.org2.example.com

Primero instalemos el código de cadena en el Org1par. Configure las siguientes variables de entorno para operar la CLI del mismo nivel como Org1usuario administrador. Se CORE_PEER_ADDRESSconfigurará para que apunte al Org1par peer0.org1.example.com:

export CORE_PEER_TLS_ENABLED=true
export CORE_PEER_LOCALMSPID="Org1MSP"
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_ADDRESS=localhost:7051

Ahora, instale el código de cadena del ciclo de vida del par en el par. Emita el comando de instalación del código de cadena del ciclo de vida del par para instalar el código de cadena en el par. No obtendrá el identificador del paquete chaincode. En el siguiente paso, usaremos este ID de paquete para aprobar el código de cadena:

peer lifecycle chaincode install basic.tar.gz
2021-02-06 09:09:27.534 IST [cli.lifecycle.chaincode] submitInstallProposal -> INFO 001 Installed remotely: response:<status:200 payload:"\nJbasic_1.0:e2db7f693d4dfwi9599953fnd00300dd0232323e9ebb88c5721cb8248c3aead8123\022\tbasic_1.0" >
2021-02-06 09:09:27.534 IST [cli.lifecycle.chaincode] submitInstallProposal -> INFO 002 Chaincode code package identifier: basic_1.0:e2db7f693d4aa6156e652741dwi487575730de9ebb88c5721cb8248c3aead8123

A continuación, instalaremos el paquete chaincode en el Org2par usando peer lifecycle chaincode install basic.tar.gz. Como hicimos anteriormente, configure las variables de entorno requeridas e instale el paquete chaincode. Nuestro Org2compañero es peer0.org2.example.com:

export CORE_PEER_LOCALMSPID="Org2MSP"
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp
export CORE_PEER_ADDRESS=localhost:9051

peer lifecycle chaincode install basic.tar.gz

Aprobar una definición de código de cadena

Cada organización participante debe acordar un paquete de código de cadena, que tiene un valor hash único y una etiqueta. Cada organización puede obtener el paquete chaincode de un desarrollador; si alguien intenta cambiar algo en el código de cadena, ese paquete de código de cadena dará un valor hash diferente en comparación con otros.

A continuación, aprobaremos el código de cadena, que incluye los parámetros importantes de la gobernanza de código de cadena, como el nombre, la versión y la política de respaldo de código de cadena para su organización.

Cada organización obtiene un ID de paquete idéntico, que es una combinación del valor hash y la etiqueta de ese paquete de código de cadena. Apruebe este ID de paquete idéntico con channelID, name, version, init-required, etc. para su organización. Ejecute el siguiente código:

peer lifecycle chaincode queryinstalled
Installed chaincodes on peer:
Package ID: basic_1.0:63828323nvsb3283283ss283932bb6cb291df20aa39542c3ef94008615704007f3, Label: basic_1.0

Establezca este ID de paquete como una variable de entorno y use el ID de paquete a continuación para aprobar:

export CC_PACKAGE_ID=basic_1.0:63828323nvsb3283283ss283932bb6cb291df20aa39542c3ef94008615704007f3

peer lifecycle chaincode approveformyorg -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --package-id $CC_PACKAGE_ID --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

Hay varias opciones que se pueden proporcionar con el comando como parámetro. Por un lado, la --package-idbandera incluye el identificador del paquete en la definición del código de cadena. El --sequenceindicador es un valor entero que realiza un seguimiento del número de veces que se ha definido o actualizado un código de cadena. Cuando el paquete chaincode se instala por primera vez, el número de secuencia se establece en 1. Por último, la --signature-policybandera se usa para especificar una política de respaldo de código de cadena.

Ahora, vamos a aprobar para Org1:

export CORE_PEER_LOCALMSPID="Org1MSP"
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
export CORE_PEER_ADDRESS=localhost:7051

peer lifecycle chaincode approveformyorg -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --package-id $CC_PACKAGE_ID --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

Se recomienda que todos los miembros del canal aprueben un código de cadena antes de confirmar la definición del código de cadena.

Enviar la definición de código de cadena al canal

Después de que un número suficiente de organizaciones haya aprobado una definición de código de cadena, una organización puede enviar la definición de código de cadena al canal. Si la mayoría de los miembros del canal han aprobado la definición, la transacción de confirmación será exitosa y los parámetros acordados en la definición del código de cadena se implementarán en el canal.

Antes de comprometerse, debemos verificar la preparación de compromiso para el canal usando el siguiente código:

peer lifecycle chaincode checkcommitreadiness [flags]

Flags:
      --channel-config-policy string   The endorsement policy associated to this chaincode specified as a channel config policy reference
  -C, --channelID string               The channel on which this command should be executed
      --collections-config string      The fully qualified path to the collection JSON file including the file name
      --connectionProfile string       The fully qualified path to the connection profile that provides the necessary connection information for the network. Note: currently only supported for providing peer connection information
  -E, --endorsement-plugin string      The name of the endorsement plugin to be used for this chaincode
  -h, --help                           help for checkcommitreadiness
      --init-required                  Whether the chaincode requires invoking 'init'
  -n, --name string                    Name of the chaincode
  -O, --output string                  The output format for query results. Default is human-readable plain-text. json is currently the only supported format.
      --peerAddresses stringArray      The addresses of the peers to connect to
      --sequence int                   The sequence number of the chaincode definition for the channel (default 1)
      --signature-policy string        The endorsement policy associated to this chaincode specified as a signature policy
      --tlsRootCertFiles stringArray   If TLS is enabled, the paths to the TLS root cert files of the peers to connect to. The order and number of certs specified should match the --peerAddresses flag
  -V, --validation-plugin string       The name of the validation plugin to be used for this chaincode
  -v, --version string                 Version of the chaincode

Global Flags:
      --cafile string                       Path to file containing PEM-encoded trusted certificate(s) for the ordering endpoint
      --certfile string                     Path to file containing PEM-encoded X509 public key to use for mutual TLS communication with the orderer endpoint
      --clientauth                          Use mutual TLS when communicating with the orderer endpoint
      --connTimeout duration                Timeout for client to connect (default 3s)
      --keyfile string                      Path to file containing PEM-encoded private key to use for mutual TLS communication with the orderer endpoint
  -o, --orderer string                      Ordering service endpoint
      --ordererTLSHostnameOverride string   The hostname override to use when validating the TLS connection to the orderer.
      --tls                                 Use TLS when communicating with the orderer endpoint

`
Veremos las banderas y los parámetros de opciones más adelante en este tutorial. Verifiquemos la preparación de la confirmación:

peer lifecycle chaincode checkcommitreadiness --channelID mychannel --name basic --version 1.0 --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem --output json

    {
            "Approvals": {
                    "Org1MSP": true,
                    "Org2MSP": true
            }
    }

Cuando ambos Org1MSPy Org2MSPestán configurados como verdaderos, ¡significa que está listo! Comprometámonos:

peer lifecycle chaincode commit -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses localhost:9051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt

Usando nuestro código de cadena

Ahora, nuestro código de cadena está instalado y listo para ser utilizado por nuestros clientes. Usemos el código de cadena para crear un conjunto inicial de activos en el libro mayor y consultar el código de cadena:

peer chaincode invoke -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n basic --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses localhost:9051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"function":"InitLedger","Args":[]}'

2021-02-06 10:09:27.534 IST [chaincodeCmd] chaincodeInvokeOrQuery -> INFO 001 Chaincode invoke successful. result: status:200

peer chaincode query -C mychannel -n basic -c '{"Args":["GetAllAssets"]}'

[{"Key":"asset1","Record":{"ID":"asset1","color":"blue","size":5,"owner":"Tomoko","appraisedValue":300}},
{"Key":"asset2","Record":{"ID":"asset2","color":"red","size":5,"owner":"Brad","appraisedValue":400}},
{"Key":"asset3","Record":{"ID":"asset3","color":"green","size":10,"owner":"Jin Soo","appraisedValue":500}},
{"Key":"asset4","Record":{"ID":"asset4","color":"yellow","size":10,"owner":"Max","appraisedValue":600}},
{"Key":"asset5","Record":{"ID":"asset5","color":"black","size":15,"owner":"Adriana","appraisedValue":700}},
{"Key":"asset6","Record":{"ID":"asset6","color":"white","size":15,"owner":"Michel","appraisedValue":800}}]

Use el docker pscomando para ver más nuestro contrato inteligente en ejecución:

$ docker ps
CONTAINER ID        IMAGE                                                                                                                                                                    COMMAND                  CREATED             STATUS              PORTS                              NAMES
7bf2f1bf792b        dev-peer0.org1.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c-69c9e3e44ed18cafd1e58de37a70e2ec54cd49c7da0cd461fbd5e333de32879b   "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes                                           dev-peer0.org1.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c
985e0967c27a        dev-peer0.org2.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c-158e9c6a4cb51dea043461fc4d3580e7df4c74a52b41e69a25705ce85405d760   "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes                                           dev-peer0.org2.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c
31fdd19c3be7        hyperledger/fabric-peer:latest                                                                                                                                           "peer node start"        About an hour ago   Up About an hour    0.0.0.0:7051->7051/tcp             peer0.org1.example.com
1b17ff866fe0        hyperledger/fabric-peer:latest                                                                                                                                           "peer node start"        About an hour ago   Up About an hour    7051/tcp, 0.0.0.0:9051->9051/tcp   peer0.org2.example.com
4cf170c7ae9b        hyperledger/fabric-orderer:latest

Escribe tu primera aplicación

Ahora, instalemos y ejecutemos nuestra aplicación JavaScript de muestra , que es una aplicación simple de Node.js:

cd asset-transfer-basic/application-javascript
npm install
ls
app.js                  node_modules            package.json       package-lock.json
node app.js

Nuestro app.jstiene los siguientes componentes principales:

  • Inscribe al usuario administrador:
async function main() {
  try {
    // build an in memory object with the network configuration (also known as a connection profile)
    const ccp = buildCCP();

    // build an instance of the fabric ca services client based on
    // the information in the network configuration
    const caClient = buildCAClient(FabricCAServices, ccp);

    // setup the wallet to hold the credentials of the application user
    const wallet = await buildWallet(Wallets, walletPath);

    // in a real application this would be done on an administrative flow, and only once
    await enrollAdmin(caClient, wallet);
  • Registra e inscribe a un usuario de la aplicación:
// in a real application this would be done only when a new user was required to be added
// and would be part of an administrative flow
await registerAndEnrollUser(caClient, wallet, mspOrg1, org1UserId, 'org1.department1');

Successfully registered and enrolled user appUser and imported it into the wallet
  • Prepara una conexión con el canal y el contrato inteligente:
// Create a new gateway instance for interacting with the fabric network.
// In a real application this would be done as the backend server session is setup for
// a user that has been verified.
const gateway = new Gateway();

try {
  // setup the gateway instance
  // The user will now be able to create connections to the fabric network and be able to
  // submit transactions and query. All transactions submitted by this gateway will be
  // signed by this user using the credentials stored in the wallet.
  await gateway.connect(ccp, {
    wallet,
    identity: userId,
    discovery: {enabled: true, asLocalhost: true} // using asLocalhost as this gateway is using a fabric network deployed locally
  });

  // Build a network instance based on the channel where the smart contract is deployed
  const network = await gateway.getNetwork(channelName);


  // Get the contract from the network.
  const contract = network.getContract(chaincodeName);
  • Inicializa el libro mayor con algunos datos de muestra:
// Initialize a set of asset data on the channel using the chaincode 'InitLedger' function.
// This type of transaction would only be run once by an application the first time it was started after it
// deployed the first time. Any updates to the chaincode deployed later would likely not need to run
// an "init" type function.
console.log('\n--> Submit Transaction: InitLedger, function creates the initial set of assets on the ledger');
await contract.submitTransaction('InitLedger');
console.log('*** Result: committed');

Submit Transaction: InitLedger, function creates the initial set of assets on the ledger
  • Invoca cada una de las funciones de código de cadena:
// GetAllAssets returns all assets found in the world state.
 async GetAllAssets(ctx) {
     const allResults = [];
     // range query with empty string for startKey and endKey does an open-ended query of all assets in the chaincode namespace.
     const iterator = await ctx.stub.getStateByRange('', '');
     let result = await iterator.next();
     while (!result.done) {
         const strValue = Buffer.from(result.value.value.toString()).toString('utf8');
         let record;
         try {
             record = JSON.parse(strValue);
         } catch (err) {
             console.log(err);
             record = strValue;
         }
         allResults.push({ Key: result.value.key, Record: record });
         result = await iterator.next();
     }
     return JSON.stringify(allResults);
 }  Evaluate Transaction: GetAllAssets, function returns all the current assets on the ledger
  Result: [
  {
    "Key": "asset1",
    "Record": {
      "ID": "asset1",
      "Color": "blue",
      "Size": 5,
      "Owner": "Tomoko",
      "AppraisedValue": 300,
      "docType": "asset"
    }
  },
  {
    "Key": "asset2",
    "Record": {
      "ID": "asset2",
      "Color": "red",
      "Size": 5,
      "Owner": "Brad",
      "AppraisedValue": 400,
      "docType": "asset"
    }
  },
  {
    "Key": "asset3",
    "Record": {
      "ID": "asset3",
      "Color": "green",
      "Size": 10,
      "Owner": "Jin Soo",
      "AppraisedValue": 500,
      "docType": "asset"
    }
  },
  {
    "Key": "asset4",
    "Record": {
      "ID": "asset4",
      "Color": "yellow",
      "Size": 10,
      "Owner": "Max",
      "AppraisedValue": 600,
      "docType": "asset"
    }
  },
  {
    "Key": "asset5",
    "Record": {
      "ID": "asset5",
      "Color": "black",
      "Size": 15,
      "Owner": "Adriana",
      "AppraisedValue": 700,
      "docType": "asset"
    }
  },
  {
    "Key": "asset6",
    "Record": {
      "ID": "asset6",
      "Color": "white",
      "Size": 15,
      "Owner": "Michel",
      "AppraisedValue": 800,
      "docType": "asset"
    }
  }// CreateAsset issues a new asset to the world state with given details.
async CreateAsset(ctx, id, color, size, owner, appraisedValue) {
  const asset = {
      ID: id,
      Color: color,
      Size: size,
      Owner: owner,
      AppraisedValue: appraisedValue,
  };
  return ctx.stub.putState(id, Buffer.from(JSON.stringify(asset)));
}

Submit Transaction: CreateAsset, creates new asset with ID, color, owner, size, and appraisedValue arguments

Conclusión

Cuando haya terminado de usar la muestra de transferencia de activos, no olvide desactivar la red de prueba con el network.shscript, liberando sus recursos con ./network.sh down. Este comando desactivará las CA, los pares y el nodo de pedido de la red que creamos. Tenga en cuenta que se perderán todos los datos del libro mayor. Reinicie con el tutorial con un estado inicial limpio.

En este artículo, exploramos en detalle la creación de contratos inteligentes con Hyperledger Fabric. Cubrimos su arquitectura, características y SDK de JavaScript. Háganos saber lo que crea y asegúrese de dejar un comentario si tiene alguna pregunta. ¡Feliz codificación!

Enlace: https://blog.logrocket.com/hyperledger-fabric-develop-blockchain-smart-contracts/  

#hyperledger #blockchain 

Desarrollar Contratos inteligentes De Blockchain Autorizados
伊藤  直子

伊藤 直子

1647352920

許可されたブロックチェーンスマートコントラクトを開発する

 Hyperledgerは、分散型台帳、オープンソースのブロックチェーン実装、および分散型台帳フレームワーク、スマートコントラクトエンジン、クライアントライブラリ、グラフィカルインターフェイス、ユーティリティライブラリ、サンプルアプリケーションなどの関連ツールを提供するLinuxFoundationによる包括的なプロジェクトです。

ブロックチェーンは、スマートコントラクトやその他の支援技術のシステムと組み合わせて、コンセンサスによって作成されたトランザクションのピアツーピア分散型台帳です。これらのトランザクションは複製され、ブロックチェーン上の参加しているコンピューターシステムのネットワーク全体に分散されます。言い換えれば、ブロックチェーンは、市場、データ共有ネットワーク、マイクロ通貨、および分散型デジタルコミュニティの法的に準拠したオペレーティングシステムです。

Hyperledger Fabricは、分散型台帳テクノロジー(DLT)が必要な統合プロジェクトを主な目的とした許可されたブロックチェーンインフラストラクチャです。Node.js、JavaScript、およびGo用のSDK以外のユーザー向けサービスは提供していません。ノード間のモジュラーアーキテクチャ、スマートコントラクトの実行、構成可能なコンセンサスおよびメンバーシップサービスを提供します。

この記事では、最初の許可されたブロックチェーンアプリケーションを作成し、スマートコントラクトを調査し、HyperledgerFabricのいくつかの重要な機能について説明します。始めましょう!

HyperledgerFabricについて

Hyperledger Fabric Networkは、3つの主要コンポーネントで構成されています。

ピアノードは、チェーンコードを実行し、元帳データにアクセスし、トランザクションを承認し、アプリケーションとインターフェイスします。ピアノードは、ブロックチェーンライフサイクルの任意の時点で開始、停止、再構成、および削除できます。

注文ノードは、ブロックチェーンの一貫性を確保し、承認されたトランザクションをネットワークのピアに配信します。注文者ノードは、トランザクションの注文、注文サービスの形成、トランザクションのブロックへのパッケージ化、およびこれらのブロックをネットワーク全体のアンカーピアに配布する役割を果たします。

メンバーシップサービスプロバイダー(MSP)ノードは、通常、認証局として実装されます。認証局は、X.509証明書を管理し、メンバーのIDとロールを認証するために使用されます。MSPノードは、証明書の発行、証明書の検証、およびユーザーの認証の背後にあるすべての暗号化メカニズムとプロトコルの抽象化レイヤーです。

ピアノード、スマートコントラクト、元帳、およびブロックチェーンネットワーク間の相互接続

Hyperledger Fabricでは、さまざまなコンセンサスアルゴリズムを使用できますが、実用的なビザンチンフォールトトレランス(PBFT)が最も一般的に使用されます。

機能性

HyperledgerFabricには5つの主要な機能があります。

ID管理

許可されたネットワークの場合、メンバーシップIDサービスはユーザーIDを管理し、ブロックチェーンネットワーク上の参加者を認証します。さらに、開発者は、アクセス制御リストを使用して、追加のレイヤーを介して特定のネットワーク操作を有効にし、制限することができます。たとえば、特定のユーザーIDがチェーンコードアプリケーションの呼び出しを許可されていても、新しいチェーンコードの展開をブロックされている可能性があります。

効率的な処理

ネットワークに同時実行性と並列性を提供するために、Hyperledger Fabricには、たとえばノードオーソリティのタイプによるトランザクションの順序付けが含まれています。開発者は、同じノードで複数のトランザクションを実行し、ノードタイプごとにネットワークロールを割り当てることができます。

モジュール設計

Hyperledger Fabricは、モジュラーアーキテクチャを実装して、ネットワーク設計者に機能的な選択肢を提供します。たとえば、さまざまな暗号化アルゴリズム、アルゴリズムまたはID、暗号化、順序付け、暗号化を利用できるため、ユニバーサルデザインが可能になります。

プライバシーと守秘義務

Hyperledger Fabricを使用すると、競合する企業や、プライベートで機密性の高いトランザクションを必要とするグループを、同じ許可されたネットワーク上で共存させることができます。ネットワークメンバーの特定のサブセットに対する制限付きメッセージングパスなどの機能をサポートします。たとえば、トランザクション、メンバー、チャネル情報などのデータは、明示的にアクセスを許可されていないネットワークメンバーには表示されず、アクセスできません。

チェーンコード機能

エンコーディングロジックは、システムチェーンコード、ライフサイクルと構成システムチェーンコード、承認と検証システムチェーンコードなど、チャネル上の特定のタイプのトランザクションによって呼び出されます。

Hyperledgerファブリックアーキテクチャ

Hyperledger Fabricの機能に慣れてきたので、それを構成するコンポーネントを確認しましょう。

ノード

Hyperledger Fabricでは、ネットワーク上で通信するコンピューティングデバイスはノードと呼ばれます。

クライアント

クライアントは、エンドユーザーに代わって動作できるノードです。

ピア

Hyperledger Fabricには、ピアノードが元帳の状態とパフォーマンスの最適化を担当するピアツーピアネットワークがあります。ピアには2つのタイプがあります。1つは、承認者がトランザクションをシミュレートして承認することです。トランザクションの承認は、シミュレートされたトランザクションの結果に対する署名された応答です。一方、コミッターは、トランザクションをブロックチェーンにコミットする前に、承認を検証し、トランザクションの結果を検証します

トランザクション

HyperledgerFabricトランザクションには2つのタイプがあります。デプロイトランザクションは、パラメータをプログラムとして使用して新しいチェーンコードを作成し、ブロックチェーンにチェーンコードをインストールします。呼び出しトランザクションは、以前のチェーンコードまたはスマートコントラクトの展開のコンテキストで実行されます。

データ構造

Key-Value Store(KVS)は、ブロックチェーンの基本的なデータ構造です。多くの場合、キーは名前であり、値はblobです。KVSは2つの操作、PUTおよびをサポートしGETます。データ構造は、特定の時点での状態と見なされます。デフォルトの状態データベースであるLevelDBは、 CouchDBに置き換えることができます。

元帳

トランザクションの順序付きハッシュチェーンブロックと呼ばれるものでは、状態の変化が発生順に保存されるため、後で簡単に参照できます。ブロックチェーンは、元帳内のトランザクションを記録します。元帳には、順序付けされたトランザクション配列を含む順序付けられたブロックが含まれています。元帳は、成功したか失敗したかにかかわらず、すべての状態変更を保存します。

ファブリックデータベース

Hyperledger Fabricでは、データは状態データベースと元帳データベースの2か所に保存されます。

現在の状態データは、元帳内のすべての資産の最新の値を表します。現在の状態は、チャネル上でコミットされたすべてのトランザクションを表すため、ワールド状態と呼ばれることもあります。

元帳データベースには、各ブロックに1つ以上のトランザクションがあるシリアル化されたブロックが格納されます。各トランザクションには、1つ以上のキーと値のペアを変更する読み取り/書き込みセットが含まれています。元帳はデータの決定的なソースであり、不変です。

注文メカニズム

Hyperledger Fabricは、3つの順序付けメカニズムを提供します。

単一の順序付けノードを含むSOLO順序付けメカニズムは、HyperledgerFabricネットワークを実験している開発者によって最も一般的に使用されます。

Kafkaの注文メカニズムは、実稼働での使用をお勧めします。データは、承認されたトランザクションとRWセットで構成されます。Apache Kafkaを使用しているため、このタイプの順序付けはクラッシュフォールトトレラントです。

最後に、Simplified Byzantine Fault Toleranceの順序付けメカニズムは、クラッシュフォールトトレラントとビザンチンフォールトトレラントの両方であり、悪意のあるノードや障害のあるノードが存在する場合でも合意に達することができます。

コンセンサス

分散型台帳システムでは、コンセンサスは、元帳に追加される次の一連のトランザクションについて合意に達するプロセスです。Hyperledger Fabricは、3つの異なるステップで構成されています。

まず、トランザクション承認ステップで、承認ピアがチェーンコードを実行します。チェーンコードが成功すると、元帳の実際のトランザクションが生成されます。次に、承認ピアがトランザクションに署名し、提案者に返します。

順序付けサービスは厳密な順序付けをサポートします。つまり、トランザクションT1がすでにブロック内に書き込まれている場合B1、同じトランザクションをまたはのT1ような別のブロックに再書き込みすることはできませB2B3。最後に、検証とコミットメントには、トランザクション検証と元帳コミットメントが含まれます。

スマートコントラクト

スマートコントラクトは、グローバル状態に含まれるビジネスオブジェクトのライフサイクルを制御するトランザクションロジックを定義します。Hyperledger Fabricでは、スマートコントラクトの実行はチェーンコードと呼ばれます。Hyperledger Fabricユーザーは、スマートコントラクトとチェーンコードという用語を同じ意味で使用することがよくあります。

Hyperledger Fabricのスマートコントラクトはチェーンコードとも呼ばれ、Goで記述されています。チェーンコードはHyperledgerFabricネットワークのビジネスロジックとして機能し、スマートコントラクトは関与するノードがネットワーク内のアセットを操作する方法を指示します。

アプリケーションがネットワークとどのように相互作用するか

Hyperledger Fabricでは、スマートコントラクトとチェーンコードがネットワーク上でホストされ、名前とバージョンで識別されます。チェーンコードまたはスマートコントラクトを実行するために、アプリケーションはSDKによって実装されるSDKAPIを使用します。

Hyperledger Fabricには、開発者がアプリケーションを作成するための3つのオプション、Node.js SDK、Java SDK、およびCLIがあります。さらに、Hyperledgerは、ユーザーがHyperledgerFabricの機能を探索するためのHyperledgerFabricサンプルを提供します。

許可されたブロックチェーンアプリケーションの開発

Hyperledger Fabricアーキテクチャを理解したので、許可されたブロックチェーンアプリケーションを作成しましょう。まず、HyperledgerFabricアプリケーションを開発するときに実行する主な手順を明確にしましょう。

まず、スマートコントラクトが実行されるネットワークのインストールを含め、開発環境をセットアップする必要があります。次に、Node.jsSDKとアプリケーションの背後にあるコアプログラミングを理解する必要があります。Hyperledger Fabricは、Go、JavaScript、Javaなどの複数のSDKを提供します。このチュートリアルでは、少しのGoとたくさんのJavaScriptを使用します。

さらに、トランザクションを含むサンプルのスマートコントラクトを理解する必要があります。アプリによってシミュレートされたクエリを実行し、元帳も更新します。最後に、スマートコントラクトを使用してサンプルブロックチェーンアプリケーションを開発します。

開発環境をセットアップする

前提条件

Hyperledger Fabricを使用して開発環境をセットアップするには、次のものが必要です。

  1. cURLの最新バージョン
  2. DockerおよびDockerCompose≥v17.06.2-ce
  3. v1.12.xに移動
  4. Node.js≥v8.9または≥v10.15.3

インストール

この例では、LinuxベースのディストリビューションUbuntu20.04および18.04を使用します。まず、現在のマシンをで更新しますsudo apt-get update。次に、以下に示すように、でcURLをインストールしsudo apt instal curl、でcURLのバージョンを確認しcurl --versionます。

 curl --version
curl 7.68.0 (x86_64-pc-linux-gnu) libcurl/7.68.0 OpenSSL/1.1.1f zlib/1.2.11 brotli/1.0.7 libidn2/2.2.0 libpsl/0.21.0 (+libidn2/2.2.0) libssh/0.9.3/openssl/zlib nghttp2/1.40.0 librtmp/2.3
Release-Date: 2020-01-08
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp 
Features: AsynchDNS brotli GSS-API HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets

Docker

必要なDockerパッケージを次のようにインストールする必要があります。

sudo apt-get install apt-transport-https ca-certificates gnupg-agent software-properties-common

次に、Dockerの公式GPGキーを追加します。

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -Check OK

Dockerをセットアップするには、次のコードを実行します。

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu  $(lsb_release -cs)  stable"

以下のコードでDockerをインストールします。

sudo apt-get install docker-ce docker-ce-cli containerd.io`

docker --version次のコードスニペットでDockerのバージョンを確認します。

logrocket:~$ docker --version
Docker version 20.10.12, build e91ed57

次に、Dockerエンジンをテスト実行します。

docker run hello-world

DockerCompose

Docker Composeの最新バージョンをダウンロードするには、次のコードを実行します。

sudo curl -L "https://github.com/docker/compose/releases/download/1.25.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

権限を実行可能ファイルに変更しsudo chmod +x /usr/local/bin/docker-composeます。Docker Composeのバージョンを確認するには、次のように実行docker-compose --versionします。

logrocket:~$ docker-compose --version
docker-compose version 1.25.5, build 8a1c60f6

行け

ファイルをダウンロードしtarます。

curl -O https://storage.googleapis.com/golang/go1.12.9.linux-amd64.tar.gz

Goディレクトリを移動します。

sudo mv go1.12.9.linux-amd64.tar.gz /usr/local/

tar以下のコードでファイルを抽出します。

sudo tar -xvzpf /usr/local/go1.12.9.linux-amd64.tar.gz

tar次のコードでファイルを削除できます。

sudo rm -rf /usr/local/go1.12.9.linux-amd64.tar.gz

環境変数

でプロファイルを開き、ファイルの最後に変数をvim .profile追加します。PATH.profile

export GOPATH=$HOME/go
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin

でソースプロファイルにsource ~/.profile移動し、次のコードで現在のGoバージョンを確認します。

logrocket:~$ go version
go version go1.12.9 linux/amd64

Node.js

以下のコードを実行して、Node.jsv10.xを取得します。

curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -`

以下のコマンドでNode.jsをインストールします。

sudo apt-get install -y nodejs

Node.jsの現在のバージョンを確認するには、次のコードを実行します。

nodejs --version
logrocket:~$ nodejs --version
v10.19.0

ここで、npmのバージョンを次のように確認しますnpm -v

logrocket:~$ npm -v
6.14.4

Hyperledgerファブリック

以下のコードを実行して、新しいディレクトリを作成します。

mkdir hyperledger-fabric && cd hyperledger-fabric

Docker権限を追加します:

sudo usermod -aG docker $USER

権限を確認し、ターミナルを更新します。

logrocket:~$ id -nG
tapasweni adm cdrom sudo dip plugdev lpadmin lxd sambashare
newgrp docker

Fabricv1.4.7をダウンロードします。

curl -sSL https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh  | bash -s -- 1.4.7 1.4.7 0.4.20


logrocket:~$ curl -sSL https://raw.githubusercontent.com/hyperledger/fabric/master/scripts/bootstrap.sh  | bash -s -- 1.4.7 1.4.7 0.4.20

Clone hyperledger/fabric-samples repo

===> Cloning hyperledger/fabric-samples repo
Cloning into 'fabric-samples'...
remote: Enumerating objects: 9165, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 9165 (delta 0), reused 1 (delta 0), pack-reused 9164
Receiving objects: 100% (9165/9165), 5.21 MiB | 3.71 MiB/s, done.
Resolving deltas: 100% (4898/4898), done.
===> Checking out v1.4.7 of hyperledger/fabric-samples

Pull Hyperledger Fabric binaries

===> Downloading version 1.4.7 platform specific fabric binaries
===> Downloading:  https://github.com/hyperledger/fabric/releases/download/v1.4.7/hyperledger-fabric-linux-amd64-1.4.7.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   680  100   680    0     0   1683      0 --:--:-- --:--:-- --:--:--  1679
100 79.3M  100 79.3M    0     0  4614k      0  0:00:17  0:00:17 --:--:-- 4762k
==> Done.
===> Downloading version 1.4.7 platform specific fabric-ca-client binary
===> Downloading:  https://github.com/hyperledger/fabric-ca/releases/download/v1.4.7/hyperledger-fabric-ca-linux-amd64-1.4.7.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   683  100   683    0     0   1876      0 --:--:-- --:--:-- --:--:--  1876
100 23.6M  100 23.6M    0     0  3962k      0  0:00:06  0:00:06 --:--:-- 4904k
==> Done.

Pull Hyperledger Fabric docker images

FABRIC_IMAGES: peer orderer ccenv tools
===> Pulling fabric Images
====> hyperledger/fabric-peer:1.4.7
1.4.7: Pulling from hyperledger/fabric-peer
Digest: sha256:a395036c83125ccf3820eb1752ac9ba8017e4432768b59d658bfba91a311d154
Status: Image is up to date for hyperledger/fabric-peer:1.4.7
docker.io/hyperledger/fabric-peer:1.4.7
====> hyperledger/fabric-orderer:1.4.7
1.4.7: Pulling from hyperledger/fabric-orderer
Digest: sha256:aef31580eee468e08eb8354bb5f2ec23e0fc12f9b638bd41d207dd5e4d6c6e60
Status: Image is up to date for hyperledger/fabric-orderer:1.4.7
docker.io/hyperledger/fabric-orderer:1.4.7
====> hyperledger/fabric-ccenv:1.4.7
1.4.7: Pulling from hyperledger/fabric-ccenv
Digest: sha256:11dbbdce7f3f789d7bbc758b593005e9aeccd991ed64a3f296e824aaf67f07c6
Status: Image is up to date for hyperledger/fabric-ccenv:1.4.7
docker.io/hyperledger/fabric-ccenv:1.4.7
====> hyperledger/fabric-tools:1.4.7
1.4.7: Pulling from hyperledger/fabric-tools
Digest: sha256:59328549b3384f565cb5bd19b74c977820781e4709158666ead74fcd970c11e1
Status: Image is up to date for hyperledger/fabric-tools:1.4.7
docker.io/hyperledger/fabric-tools:1.4.7
===> Pulling fabric ca Image
====> hyperledger/fabric-ca:1.4.7
1.4.7: Pulling from hyperledger/fabric-ca
Digest: sha256:9418ea351bfbef4bf2bca34bcd77305bdb9a45d2c1aab3237c08c17da0b4d1dd
Status: Image is up to date for hyperledger/fabric-ca:1.4.7
docker.io/hyperledger/fabric-ca:1.4.7
===> List out hyperledger docker images
hyperledger/fabric-ca        1.4            743a758fae29   19 months ago   154MB
hyperledger/fabric-ca        1.4.7          743a758fae29   19 months ago   154MB
hyperledger/fabric-ca        latest         743a758fae29   19 months ago   154MB
hyperledger/fabric-tools     1.4            a026b435e575   19 months ago   1.49GB
hyperledger/fabric-tools     1.4.7          a026b435e575   19 months ago   1.49GB
hyperledger/fabric-tools     latest         a026b435e575   19 months ago   1.49GB
hyperledger/fabric-ccenv     1.4            c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-ccenv     1.4.7          c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-ccenv     latest         c5fbec1827ad   19 months ago   1.36GB
hyperledger/fabric-orderer   1.4            df155b01ed80   19 months ago   123MB
hyperledger/fabric-orderer   1.4.7          df155b01ed80   19 months ago   123MB
hyperledger/fabric-orderer   latest         df155b01ed80   19 months ago   123MB
hyperledger/fabric-peer      1.4            5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-peer      1.4.7          5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-peer      latest         5d5fbecd1efe   19 months ago   131MB
hyperledger/fabric-baseos    amd64-0.4.20   121a92cc3fc0   22 months ago   85MB
logrocket:~$ cURL hyperledger/fabric-samples

次に、環境変数を更新します。

vim .profile
export PATH=/home/$USER/hyperledger/fabric-samples/bin:$PATH
source ~/.profile

HyperledgerFabricを実行する

中に入るfabric-samples/first-network

HyperledgerFabricの最初のネットワークディレクトリ

ネットワークを立ち上げる./byfn.sh up

logrocket:~$ cd first-network/
logrocket:~$ ls
base               channel-artifacts     connection-org2.yaml    docker-compose-cli.yaml           docker-compose-kafka.yaml  scripts
byfn.sh            configtx.yaml         connection-org3.json    docker-compose-couch-org3.yaml    docker-compose-org3.yaml
ccp-generate.sh    connection-org1.json  connection-org3.yaml    docker-compose-couch.yaml         eyfn.sh
ccp-template.json  connection-org1.yaml  crypto-config.yaml      docker-compose-e2e-template.yaml  org3-artifacts
ccp-template.yaml  connection-org2.json  docker-compose-ca.yaml  docker-compose-etcdraft2.yaml     README.md
logrocket:~$ ./byfn.sh -m up
Starting for channel 'mychannel' with CLI timeout of '10' seconds and CLI delay of '3' seconds
Continue? [Y/n] 
proceeding ...
LOCAL_VERSION=1.4.7
DOCKER_IMAGE_VERSION=1.4.7
/home/tapasweni/hyperledger/fabric-samples/first-network/../bin/cryptogen

##########################################################
##### Generate certificates using cryptogen tool #########
##########################################################
+ cryptogen generate --config=./crypto-config.yaml
org1.example.com
org2.example.com
+ res=0
+ set +x

Generate CCP files for Org1 and Org2
/home/tapasweni/hyperledger/fabric-samples/first-network/../bin/configtxgen
##########################################################
#########  Generating Orderer Genesis block ##############
##########################################################
CONSENSUS_TYPE=solo
+ '[' solo == solo ']'
+ configtxgen -profile TwoOrgsOrdererGenesis -channelID byfn-sys-channel -outputBlock ./channel-artifacts/genesis.block
2021-12-31 17:52:52.853 IST [common.tools.configtxgen] main -> INFO 001 Loading configuration
2021-12-31 17:52:53.051 IST [common.tools.configtxgen.localconfig] completeInitialization -> INFO 002 orderer type: solo
2021-12-31 17:52:53.051 IST [common.tools.configtxgen.localconfig] Load -> INFO 003 Loaded configuration: /home/tapasweni/hyperledger/fabric-samples/first-network/configtx.yaml

Dockerを次のように確認しdocker ps -aます:

logrocket:~$ docker ps -a
CONTAINER ID   IMAGE                                                                                                  COMMAND                  CREATED              STATUS              PORTS                                           NAMES
ef86361332c7   dev-peer1.org2.example.com-mycc-1.0-26c2ef32838554aac4f7ad6f100aca865e87959c9a126e86d764c8d01f8346ab   "chaincode -peer.add…"   About a minute ago   Up About a minute                                                   dev-peer1.org2.example.com-mycc-1.0
c9008d040273   dev-peer0.org1.example.com-mycc-1.0-384f11f484b9302df90b453200cfb25174305fce8f53f4e94d45ee3b6cab0ce9   "chaincode -peer.add…"   2 minutes ago        Up 2 minutes                                                        dev-peer0.org1.example.com-mycc-1.0
9ad7861a975c   dev-peer0.org2.example.com-mycc-1.0-15b571b3ce849066b7ec74497da3b27e54e0df1345daff3951b94245ce09c42b   "chaincode -peer.add…"   4 minutes ago        Up 4 minutes                                                        dev-peer0.org2.example.com-mycc-1.0
91ce4e6cfaf5   hyperledger/fabric-tools:latest                                                                        "/bin/bash"              5 minutes ago        Up 5 minutes                                                        cli
c4e3238a2301   hyperledger/fabric-orderer:latest                                                                      "orderer"                6 minutes ago        Up 5 minutes        0.0.0.0:7050->7050/tcp, :::7050->7050/tcp       orderer.example.com
416a0f98cb6b   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:10051->10051/tcp, :::10051->10051/tcp   peer1.org2.example.com
84e42d29fab9   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:7051->7051/tcp, :::7051->7051/tcp       peer0.org1.example.com
7ad2e6e34292   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:8051->8051/tcp, :::8051->8051/tcp       peer1.org1.example.com
9ff94883cacf   hyperledger/fabric-peer:latest                                                                         "peer node start"        6 minutes ago        Up 5 minutes        0.0.0.0:9051->9051/tcp, :::9051->9051/tcp       peer0.org2.example.com
logrocket:~$ 

次のコマンドでネットワークを停止し./byfn.sh downます。

logrocket:~$ ./byfn.sh -m down
Stopping for channel 'mychannel' with CLI timeout of '10' seconds and CLI delay of '3' seconds
Continue? [Y/n] 
proceeding ...
WARNING: The BYFN_CA1_PRIVATE_KEY variable is not set. Defaulting to a blank string.
WARNING: The BYFN_CA2_PRIVATE_KEY variable is not set. Defaulting to a blank string.
Stopping cli                    ... done
Stopping peer0.org2.example.com ... done
Stopping peer0.org1.example.com ... done
Stopping peer1.org2.example.com ... done
Stopping peer1.org1.example.com ... done
Stopping orderer.example.com    ... done
Removing cli                    ... done
Removing peer0.org2.example.com ... done
Removing peer0.org1.example.com ... done
Removing peer1.org2.example.com ... done
Removing peer1.org1.example.com ... done
Removing orderer.example.com    ... done
Removing network net_byfn
Removing volume net_orderer.example.com
Removing volume net_peer0.org1.example.com
Removing volume net_peer1.org1.example.com
Removing volume net_peer0.org2.example.com
Removing volume net_peer1.org2.example.com
Removing volume net_orderer2.example.com
WARNING: Volume net_orderer2.example.com not found.
Removing volume net_orderer3.example.com
WARNING: Volume net_orderer3.example.com not found.
Removing volume net_orderer4.example.com
WARNING: Volume net_orderer4.example.com not found.
Removing volume net_orderer5.example.com
WARNING: Volume net_orderer5.example.com not found.
Removing volume net_peer0.org3.example.com
WARNING: Volume net_peer0.org3.example.com not found.
Removing volume net_peer1.org3.example.com
WARNING: Volume net_peer1.org3.example.com not found.
1c1c3bd27578
052b542e408f
2371102e3fa1
Untagged: dev-peer1.org2.example.com-mycc-1.0-26c2ef32838554aac4f7ad6f100aca865e87959c9a126e86d764c8d01f8346ab:latest
Deleted: sha256:574b46ed09496b052b9963d79362fa3e15d5430d6f7e227c8edccfe37a94a54d
Deleted: sha256:89856e5feb7feafde31a15decf9d2657f7344e38ee90bc8e73f7c0e189a0422c
Deleted: sha256:570373df622999f59a978635db23a4ce6f6f3c6b1067aeafd3d2a64b4b1020b0
Deleted: sha256:31ce9090622db38830dfdc3209c4044d70f7345e863fcd54c40ac2d2a2abbf03
Untagged: dev-peer0.org1.example.com-mycc-1.0-384f11f484b9302df90b453200cfb25174305fce8f53f4e94d45ee3b6cab0ce9:latest
Deleted: sha256:c40d025bb22f74cfa14568a70257964d94b557e23811c9bfb5d4591200f64b62
Deleted: sha256:b9e1d83750424813abf0fe6f96fbc3904680bf0ae23474b4939e60596b77f1d9
Deleted: sha256:a5dc79ea636789a36962fcac872a77a86235f95fa9f3714c8bd8da42237b51f3
Deleted: sha256:8b9a4e82ec7825be4e6f52b7192c2b76fc5ab671a871dcc9c3423f23713009da
Untagged: dev-peer0.org2.example.com-mycc-1.0-15b571b3ce849066b7ec74497da3b27e54e0df1345daff3951b94245ce09c42b:latest
Deleted: sha256:599b2ad18745375616a97b3a99411571aeb456b0c320f853bdd9d15d19a5c875
Deleted: sha256:65a03c40d4a982f5b6589a8fd2e6aac66b70a295d68b3c8892a8fe5bf41f3edc
Deleted: sha256:ab76526d7091a8511de05ae2c91f0279f10aa0b07ad4a62c5cc105c454d79894
Deleted: sha256:6d5781813eb41dfc57917af52d5c4e7234864d005b8d38c07f51a759fa8790f0
logrocket:~$

mychannelで名前を付けたチャネルを作成します./network.sh up createChannel

    ========= Channel successfully joined ===========

Hyperledger Fabric Node.js SDK

このチュートリアルでは、Hyperledger Node.js SDKを使用します。これを使用して、ネットワークと対話し、ネットワーク、元帳、およびAPIを介してスマートコントラクトをデプロイします。

SDK

Fabricネットワーククライアントと対話するには、FabricCAの傘下にあるFabric -CAClientを使用します。Fabric CAコンポーネントを使用すると、アプリケーションはピアとアプリケーションユーザーを登録して、ブロックチェーンネットワーク上に信頼できるIDを確立できます。また、トランザクション証明書を使用した仮名トランザクション送信のサポートも提供します。

Fabric Commonパッケージは、すべてのfabric-sdk-nodeパッケージで使用される共通コードをカプセル化し、トランザクション呼び出しを送信するためのFabricネットワークとのきめ細かい相互作用をサポートします。

ファブリックネットワークは、ファブリックブロックチェーンネットワークとの接続を確立する責任があります。このパッケージは、APIをカプセル化して、Fabricネットワークに接続し、トランザクションを送信し、FabricCommonよりも高いレベルの抽象化で元帳に対してクエリを実行します。

最後に、fabric-protosパッケージは、gRPCを介した通信に使用されるprotobuffersをカプセル化します。

APIのインストール

ネットワークAPIをインストールします。

npm install fabric-network

クライアントAPIをインストールします。

npm install fabric-ca-client

共通APIをインストールします。

npm install fabric-common

protobuffersAPIをインストールします。

npm install fabric-protos

SDKの使用を開始する

Gatewayクラスは、Hyperledger Fabricブロックチェーンネットワークと対話するために使用されるエントリポイントであり、最初に開始されます。長寿命オブジェクトは、Fabricブロックチェーンネットワーク内のピアへの再利用可能な接続を提供し、その特定のピアがメンバーになっているブロックチェーンネットワークまたはチャネルへのアクセスを可能にします。

次に、そのブロックチェーンネットワーク内で実行および展開されているスマートコントラクト/チェーンコードにアクセスします。トランザクションがトリガーされ、クエリがこのブロックチェーンネットワークに対して評価されます。

スマートコントラクトイベントリスナーを使用すると、クライアントアプリケーションは、スマートコントラクトトランザクションによって発行されたチェーンコードイベントに応答してアクションまたはビジネスプロセスを開始できます。元帳へのすべての更新は、ブロックイベントリスナーを使用して監視できます。

キーチェーンコードAPI

ChaincodeStubは、開発者が基礎となる元帳と対話してアセットを照会、更新、および削除できるようにする機能を提供します。

func (stub *ChaincodeStub) GetState(key string) ([]byte, error)

上記のコードは、指定されたキーの値を元帳から返します。キーが状態データベースに存在しない場合は、nil, nil次が返されます。

func (stub *ChaincodeStub) PutState(key string, value []byte) error 

上記のコードは、指定されたキーと値をトランザクションに入れ、データ書き込みプロポーザルとして書き込みます。PutStateトランザクションが検証されて正常にコミットされるまで、元帳には影響しません。

func (stub *ChaincodeStub) DelState(key string) error

上記のコードWriteは、トランザクション提案のセットで削除される指定されたキーを記録します。トランザクションが検証され、正常にコミットされると、キーとその値が元帳から削除されます。

fabric-contract-apiスマートコントラクトまたはチェーンコードの技術用語でビジネスロジックを記述するコントラクトインターフェイスを提供します。

このCommercialPaperContract extends Contract {...}クラスには、コマーシャルペーパー、発行、購入、および償還のトランザクション定義が含まれています。

Initチェーンコード内にとInvokeメソッドの両方を作成する必要があります。チェーンコードを呼び出す前に、ピアチェーンコードinstallinstantiateコマンドをそれぞれ使用してチェーンコードをインストールおよびインスタンス化する必要があります。

これまでのところ、Hyperledger Fabric、そのアーキテクチャ、セットアップ、機能、およびSDKについての理解はこれで完了です。記事の次のパートでは、アプリケーションをインストールし、スマートコントラクトについて詳しく説明します。

サンプルのスマートコントラクトを理解する

In Hyperledger Fabric, the core business logic and rules are defined by smart contracts or chaincode. End users interact with the blockchain network and blockchain ledger by calling a smart contract’s defined rules, invoking smart contracts or chaincode.

Let’s assume that user U has implemented smart contract SC. Anyone who wants to participate, whether an organization or group, has to validate transactions or query the blockchain ledger, which can be accomplished by installing the chaincode on their peers.

After installing or deploying the smart contract or chaincode, peers join the channel. Channel members can then deploy the chaincode to the channel and use the smart contract business logic or rules in the chaincode to create or update assets on the channel ledger.

So far, we’ve already successfully created the channel. We will not use the Peer CLI provided by Hyperledger Fabric to deploy the assets-transfer package chaincode to the channel. Instead, first, let’s package the smart contract. To be installed on any participating machine, the chaincode should be packaged in the .tar.gz file. In other words, a peer that is a participating unit on the network can interact with other machines and computing devices on the blockchain network.

Next, we install the chaincode package, which has to be installed on every peer of the participating organization to follow each others’ rules or business logic. Before participating with these organization on the blockchain network, a certain threshold of peers who are a part of the organization must approve the chaincode definition. Finally, to further invoke the business logic or rules set for interaction, each channel should have the chaincode committed.

Package smart contract

Let’s review our sample JavaScript chaincode. In fabric-samples, you’ll go to the basic Go version of the asset-transfer chaincode with cd fabric-samples/asset-transfer-basic/chaincode-javascript.

The sample uses node modules to install and deploy the chaincode. package.json describes the dependencies required to package and install our chaincode. If you’ve thoroughly understood the first part, these dependencies will be familiar to you:

$ cat package.json

"dependencies": {
        "fabric-contract-api": "^2.0.0",
        "fabric-shim": "^2.0.0"

Let’s review the fabric-contract-api of our sample smart contract:

const { Contract } = require('fabric-contract-api');

class AssetTransfer extends Contract {
    ...
}

The code above will enable basic CRUD operations on our ledger, or in other words, read and write to the blockchain ledger using different function calls:

async CreateAsset(ctx, id, color, size, owner, appraisedValue) {
        const asset = {
            ID: id,
            Color: color,
            Size: size,
            Owner: owner,
            AppraisedValue: appraisedValue,
        };

        await ctx.stub.putState(id, Buffer.from(JSON.stringify(asset)));
    }

 

Inside this directory, run npm install to install any dependencies required by our chaincode package before installing or deploying chaincode on the ledger. To create a chaincode package, go to test-network and set config paths as follows:

cd ../../test-network
export PATH=${PWD}/../bin:$PATH
export FABRIC_CFG_PATH=$PWD/../config/

Run peer version to make sure you’re able to interact with the peer CLI:

logrocket:~$ peer version
peer:
 Version: 1.4.7
 Commit SHA: e0afaa741
 Go version: go1.13.9
 OS/Arch: linux/amd64
 Chaincode:
  Base Image Version: 0.4.20
  Base Docker Namespace: hyperledger
  Base Docker Label: org.hyperledger.fabric
  Docker Namespace: hyperledger

Let’s package our chaincode using the command below:

peer lifecycle chaincode package basic.tar.gz --path ../asset-transfer-basic/chaincode-javascript/ --lang node --label basic_1.0

Now, you can install the basic.tar.gz file on the network of your choice. Your chaincode or smart contract is ready to be installed, establish interactions with the ledger, and eventually become one of them by abiding by the smart contract.

Install the chaincode package

Let’s install the basic, packaged asset-transfer smart contract/chaincode on our peers. Think about our user U and smart contract SC. Let’s create two organizations, Org1 and Org2. As in our example, both organizations require endorsements from each other, so chaincode will be installed on every peer operated by both organizations:

peer0.org1.example.com
peer0.org2.example.com

Let’s install the chaincode on the Org1 peer first. Set the following environment variables to operate the peer CLI as the Org1 admin user. The CORE_PEER_ADDRESS will be set to point to the Org1 peer, peer0.org1.example.com:

export CORE_PEER_TLS_ENABLED=true
export CORE_PEER_LOCALMSPID="Org1MSP"
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_ADDRESS=localhost:7051

Now, install the peer lifecycle chaincode on the peer. Issue the peer lifecycle chaincode install command to install the chaincode on the peer. You will not get the chaincode package identifier. In the next step, we’ll use this package ID to approve the chaincode:

peer lifecycle chaincode install basic.tar.gz
2021-02-06 09:09:27.534 IST [cli.lifecycle.chaincode] submitInstallProposal -> INFO 001 Installed remotely: response:<status:200 payload:"\nJbasic_1.0:e2db7f693d4dfwi9599953fnd00300dd0232323e9ebb88c5721cb8248c3aead8123\022\tbasic_1.0" >
2021-02-06 09:09:27.534 IST [cli.lifecycle.chaincode] submitInstallProposal -> INFO 002 Chaincode code package identifier: basic_1.0:e2db7f693d4aa6156e652741dwi487575730de9ebb88c5721cb8248c3aead8123

Next, we’ll install the chaincode package on the Org2 peer using peer lifecycle chaincode install basic.tar.gz. As we did earlier, set the required environment variables and install the chaincode package. Our Org2 peer is peer0.org2.example.com:

export CORE_PEER_LOCALMSPID="Org2MSP"
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org2.example.com/users/Admin@org2.example.com/msp
export CORE_PEER_ADDRESS=localhost:9051

peer lifecycle chaincode install basic.tar.gz

Approve a chaincode definition

Each participating organization has to agree on a chaincode package, which has a unique hash value and a label. Each organization may get the chaincode package from a developer; if someone tries to change something on the chaincode, that chaincode package will give a different hash value compares to others.

Next, we’ll approve the chaincode, which includes the important parameters of chaincode governance, like the name, version, and the chaincode endorsement policy for your organization.

Each organization gets an identical Package ID, which is a combination of that chaincode package’s hash value and label. Approve this identical Package ID with channelID, name, version, init-required, etc. for your organization. Run the code below:

peer lifecycle chaincode queryinstalled
Installed chaincodes on peer:
Package ID: basic_1.0:63828323nvsb3283283ss283932bb6cb291df20aa39542c3ef94008615704007f3, Label: basic_1.0

Set this package ID as an environment variable and use the package ID below to approve:

export CC_PACKAGE_ID=basic_1.0:63828323nvsb3283283ss283932bb6cb291df20aa39542c3ef94008615704007f3

peer lifecycle chaincode approveformyorg -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --package-id $CC_PACKAGE_ID --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

There are multiple options that can be supplied with the command as parameter. For one, the --package-id flag includes the package identifier in the chaincode definition. The --sequence flag is an integer value that keeps track of the number of times a chaincode has been defined or updated. When the chaincode package is installed for first time, the sequence number is set to 1. Lastly, the --signature-policy flag is used to specify a chaincode endorsement policy.

Now, let approve for Org1:

export CORE_PEER_LOCALMSPID="Org1MSP"
export CORE_PEER_MSPCONFIGPATH=${PWD}/organizations/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp
export CORE_PEER_TLS_ROOTCERT_FILE=${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
export CORE_PEER_ADDRESS=localhost:7051

peer lifecycle chaincode approveformyorg -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --package-id $CC_PACKAGE_ID --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem

It’s recommended that all channel members approve a chaincode before committing the chaincode definition.

Committing the chaincode definition to the channel

After a sufficient number of organizations have approved a chaincode definition, one organization can commit the chaincode definition to the channel. If a majority of channel members have approved the definition, the commit transaction will be successful, and the parameters agreed to in the chaincode definition will be implemented on the channel.

Before committing, we need to check commit readiness to channel using the code below:

peer lifecycle chaincode checkcommitreadiness [flags]

Flags:
      --channel-config-policy string   The endorsement policy associated to this chaincode specified as a channel config policy reference
  -C, --channelID string               The channel on which this command should be executed
      --collections-config string      The fully qualified path to the collection JSON file including the file name
      --connectionProfile string       The fully qualified path to the connection profile that provides the necessary connection information for the network. Note: currently only supported for providing peer connection information
  -E, --endorsement-plugin string      The name of the endorsement plugin to be used for this chaincode
  -h, --help                           help for checkcommitreadiness
      --init-required                  Whether the chaincode requires invoking 'init'
  -n, --name string                    Name of the chaincode
  -O, --output string                  The output format for query results. Default is human-readable plain-text. json is currently the only supported format.
      --peerAddresses stringArray      The addresses of the peers to connect to
      --sequence int                   The sequence number of the chaincode definition for the channel (default 1)
      --signature-policy string        The endorsement policy associated to this chaincode specified as a signature policy
      --tlsRootCertFiles stringArray   If TLS is enabled, the paths to the TLS root cert files of the peers to connect to. The order and number of certs specified should match the --peerAddresses flag
  -V, --validation-plugin string       The name of the validation plugin to be used for this chaincode
  -v, --version string                 Version of the chaincode

Global Flags:
      --cafile string                       Path to file containing PEM-encoded trusted certificate(s) for the ordering endpoint
      --certfile string                     Path to file containing PEM-encoded X509 public key to use for mutual TLS communication with the orderer endpoint
      --clientauth                          Use mutual TLS when communicating with the orderer endpoint
      --connTimeout duration                Timeout for client to connect (default 3s)
      --keyfile string                      Path to file containing PEM-encoded private key to use for mutual TLS communication with the orderer endpoint
  -o, --orderer string                      Ordering service endpoint
      --ordererTLSHostnameOverride string   The hostname override to use when validating the TLS connection to the orderer.
      --tls                                 Use TLS when communicating with the orderer endpoint

`
We’ll see the flags and option parameters later in this tutorial. Let’s check commit readiness:

peer lifecycle chaincode checkcommitreadiness --channelID mychannel --name basic --version 1.0 --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem --output json

    {
            "Approvals": {
                    "Org1MSP": true,
                    "Org2MSP": true
            }
    }

When both Org1MSP and Org2MSP are set to true, it means it’s ready! Let’s commit:

peer lifecycle chaincode commit -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --channelID mychannel --name basic --version 1.0 --sequence 1 --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses localhost:9051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt

Using our chaincode

Now, our chaincode is installed and ready to be used by our clients. Let’s use the chaincode to create an initial set of assets on the ledger and query the chaincode:

peer chaincode invoke -o localhost:7050 --ordererTLSHostnameOverride orderer.example.com --tls --cafile ${PWD}/organizations/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem -C mychannel -n basic --peerAddresses localhost:7051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt --peerAddresses localhost:9051 --tlsRootCertFiles ${PWD}/organizations/peerOrganizations/org2.example.com/peers/peer0.org2.example.com/tls/ca.crt -c '{"function":"InitLedger","Args":[]}'

2021-02-06 10:09:27.534 IST [chaincodeCmd] chaincodeInvokeOrQuery -> INFO 001 Chaincode invoke successful. result: status:200

peer chaincode query -C mychannel -n basic -c '{"Args":["GetAllAssets"]}'

[{"Key":"asset1","Record":{"ID":"asset1","color":"blue","size":5,"owner":"Tomoko","appraisedValue":300}},
{"Key":"asset2","Record":{"ID":"asset2","color":"red","size":5,"owner":"Brad","appraisedValue":400}},
{"Key":"asset3","Record":{"ID":"asset3","color":"green","size":10,"owner":"Jin Soo","appraisedValue":500}},
{"Key":"asset4","Record":{"ID":"asset4","color":"yellow","size":10,"owner":"Max","appraisedValue":600}},
{"Key":"asset5","Record":{"ID":"asset5","color":"black","size":15,"owner":"Adriana","appraisedValue":700}},
{"Key":"asset6","Record":{"ID":"asset6","color":"white","size":15,"owner":"Michel","appraisedValue":800}}]

Use the docker ps command to further see our smart contract running:

$ docker ps
CONTAINER ID        IMAGE                                                                                                                                                                    COMMAND                  CREATED             STATUS              PORTS                              NAMES
7bf2f1bf792b        dev-peer0.org1.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c-69c9e3e44ed18cafd1e58de37a70e2ec54cd49c7da0cd461fbd5e333de32879b   "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes                                           dev-peer0.org1.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c
985e0967c27a        dev-peer0.org2.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c-158e9c6a4cb51dea043461fc4d3580e7df4c74a52b41e69a25705ce85405d760   "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes                                           dev-peer0.org2.example.com-basic_2.0-572cafd6a972a9b6aa3fa4f6a944efb6648d363c0ba4602f56bc8b3f9e66f46c
31fdd19c3be7        hyperledger/fabric-peer:latest                                                                                                                                           "peer node start"        About an hour ago   Up About an hour    0.0.0.0:7051->7051/tcp             peer0.org1.example.com
1b17ff866fe0        hyperledger/fabric-peer:latest                                                                                                                                           "peer node start"        About an hour ago   Up About an hour    7051/tcp, 0.0.0.0:9051->9051/tcp   peer0.org2.example.com
4cf170c7ae9b        hyperledger/fabric-orderer:latest

Write your first application

Now, let’s install and run our sample JavaScript application, which is a simple Node.js application:

cd asset-transfer-basic/application-javascript
npm install
ls
app.js                  node_modules            package.json       package-lock.json
node app.js

Our app.js has the following main components:

  • Enrolls the admin user:
async function main() {
  try {
    // build an in memory object with the network configuration (also known as a connection profile)
    const ccp = buildCCP();

    // build an instance of the fabric ca services client based on
    // the information in the network configuration
    const caClient = buildCAClient(FabricCAServices, ccp);

    // setup the wallet to hold the credentials of the application user
    const wallet = await buildWallet(Wallets, walletPath);

    // in a real application this would be done on an administrative flow, and only once
    await enrollAdmin(caClient, wallet);
  • Registers and enrolls an application user:
// in a real application this would be done only when a new user was required to be added
// and would be part of an administrative flow
await registerAndEnrollUser(caClient, wallet, mspOrg1, org1UserId, 'org1.department1');

Successfully registered and enrolled user appUser and imported it into the wallet
  • Prepares a connection to the channel and smart contract:
// Create a new gateway instance for interacting with the fabric network.
// In a real application this would be done as the backend server session is setup for
// a user that has been verified.
const gateway = new Gateway();

try {
  // setup the gateway instance
  // The user will now be able to create connections to the fabric network and be able to
  // submit transactions and query. All transactions submitted by this gateway will be
  // signed by this user using the credentials stored in the wallet.
  await gateway.connect(ccp, {
    wallet,
    identity: userId,
    discovery: {enabled: true, asLocalhost: true} // using asLocalhost as this gateway is using a fabric network deployed locally
  });

  // Build a network instance based on the channel where the smart contract is deployed
  const network = await gateway.getNetwork(channelName);


  // Get the contract from the network.
  const contract = network.getContract(chaincodeName);
  • Initializes the ledger with some sample data:
// Initialize a set of asset data on the channel using the chaincode 'InitLedger' function.
// This type of transaction would only be run once by an application the first time it was started after it
// deployed the first time. Any updates to the chaincode deployed later would likely not need to run
// an "init" type function.
console.log('\n--> Submit Transaction: InitLedger, function creates the initial set of assets on the ledger');
await contract.submitTransaction('InitLedger');
console.log('*** Result: committed');

Submit Transaction: InitLedger, function creates the initial set of assets on the ledger
  • Invokes each of the chaincode functions:
// GetAllAssets returns all assets found in the world state.
 async GetAllAssets(ctx) {
     const allResults = [];
     // range query with empty string for startKey and endKey does an open-ended query of all assets in the chaincode namespace.
     const iterator = await ctx.stub.getStateByRange('', '');
     let result = await iterator.next();
     while (!result.done) {
         const strValue = Buffer.from(result.value.value.toString()).toString('utf8');
         let record;
         try {
             record = JSON.parse(strValue);
         } catch (err) {
             console.log(err);
             record = strValue;
         }
         allResults.push({ Key: result.value.key, Record: record });
         result = await iterator.next();
     }
     return JSON.stringify(allResults);
 }  Evaluate Transaction: GetAllAssets, function returns all the current assets on the ledger
  Result: [
  {
    "Key": "asset1",
    "Record": {
      "ID": "asset1",
      "Color": "blue",
      "Size": 5,
      "Owner": "Tomoko",
      "AppraisedValue": 300,
      "docType": "asset"
    }
  },
  {
    "Key": "asset2",
    "Record": {
      "ID": "asset2",
      "Color": "red",
      "Size": 5,
      "Owner": "Brad",
      "AppraisedValue": 400,
      "docType": "asset"
    }
  },
  {
    "Key": "asset3",
    "Record": {
      "ID": "asset3",
      "Color": "green",
      "Size": 10,
      "Owner": "Jin Soo",
      "AppraisedValue": 500,
      "docType": "asset"
    }
  },
  {
    "Key": "asset4",
    "Record": {
      "ID": "asset4",
      "Color": "yellow",
      "Size": 10,
      "Owner": "Max",
      "AppraisedValue": 600,
      "docType": "asset"
    }
  },
  {
    "Key": "asset5",
    "Record": {
      "ID": "asset5",
      "Color": "black",
      "Size": 15,
      "Owner": "Adriana",
      "AppraisedValue": 700,
      "docType": "asset"
    }
  },
  {
    "Key": "asset6",
    "Record": {
      "ID": "asset6",
      "Color": "white",
      "Size": 15,
      "Owner": "Michel",
      "AppraisedValue": 800,
      "docType": "asset"
    }
  }// CreateAsset issues a new asset to the world state with given details.
async CreateAsset(ctx, id, color, size, owner, appraisedValue) {
  const asset = {
      ID: id,
      Color: color,
      Size: size,
      Owner: owner,
      AppraisedValue: appraisedValue,
  };
  return ctx.stub.putState(id, Buffer.from(JSON.stringify(asset)));
}

Submit Transaction: CreateAsset, creates new asset with ID, color, owner, size, and appraisedValue arguments

Conclusion

network.shアセット転送サンプルの使用が終了したら、スクリプトを使用してテストネットワークを停止し、を使用してリソースを解放することを忘れないでください./network.sh down。このコマンドは、作成したネットワークのCA、ピア、および順序付けノードを停止します。元帳のすべてのデータが失われることに注意してください。クリーンな初期状態でチュートリアルを再開します。

この記事では、HyperledgerFabricを使用したスマートコントラクトの作成について詳しく説明しました。そのアーキテクチャ、機能、JavaScriptSDKについて説明しました。作成したものをお知らせください。ご不明な点がございましたら、必ずコメントを残してください。ハッピーコーディング!

リンク:https ://blog.logrocket.com/hyperledger-fabric-develop-blockchain-smart-contracts/

#hyperledger  #blockchain 

許可されたブロックチェーンスマートコントラクトを開発する

Smart Contract Development Guide for Business Owners

https://www.blog.duomly.com/smart-contract-development-guide/

As a business owner, you may have heard of the term “smart contract” and wondered what it is and how it could benefit your business. Smart contracts are digital contracts that use blockchain technology to automate the negotiation and execution of transactions.

If you’d like to learn more about smart contract development, please read our guide on how to get started. In it, we’ll teach you the basics of smart contract development and how to apply it to your business.

#blockchain #hyperledger #softwaredevelopment #developer #development #decentralized #blockchaindevelopment #smartcontract

Smart Contract Development Guide for Business Owners

What is Blockchain - Guide for Business Owners

https://www.blog.duomly.com/what-is-blockchain/

If you’re a business owner, you’ve probably heard the term “blockchain” floating around lately. But what is blockchain, exactly? And what does it mean for your business?

In short, blockchain is a distributed database that allows for secure, transparent, and tamper-proof transactions between two or more parties. This transparency and security have caught the attention of businesses and investors alike.

But what does that mean for your business specifically? In this guide, we’ll explore what blockchain is, how it works and what benefits it could offer your business. We’ll also look at some potential applications of blockchain technology in the business world. So whether you’re just starting to learn about blockchain or you’re ready to start implementing it, what you’ll find below is what you need to know.


#blockchain #hyperledger #tech #programming #business #startup #token #tokenization #tokens #crypto #cryptocurrency 

What is Blockchain - Guide for Business Owners

Blockchain Development Guide for Business Owners

https://www.blog.duomly.com/blockchain-development-guide/

This article introduces you to blockchain development basics, how much it costs, finding developers, and where to look for them. 

#blockchain #hyperledger #software-development #developer #development #decentralized 

Blockchain Development Guide for Business Owners

What is Smart Contract - Guide for Business Owners

https://www.blog.duomly.com/what-is-smart-contract/

When most people think about contracts, they think about the mundane paperwork task that needs to be completed for two or more parties to exchange goods or services. However, what if there was a way to streamline this process and make it more efficient? Thanks to blockchain technology and smart contracts, this is now a possibility.

In this guide, you will learn what smart contracts are and how they can benefit your business. You will also learn about the different types of smart contracts that are available and how to create and execute them. So whether you are just starting out in business or looking for ways to improve your current operations, read on for all the information you need.

#solidity #smart #blockchain #hyperledger #crypto #cryptocurrency #cryptocurrencies #business #businesses #token #tokens 

What is Smart Contract - Guide for Business Owners

NFT Development Guide for Business Owners

https://www.blog.duomly.com/nft-development-guide/

If you’re a business owner, you know that staying ahead of the competition is key to success. And to stay ahead, you need to be constantly innovating and evolving your business model. But how do you do that? How can you create something new when everything around you seems so familiar?

One way to develop new ideas is to explore the world of NFT development. NFTs are a relatively new technology, and there are still many possibilities for what they can be used for. So if you’re looking for ways to take your business to the next level, then NFT development may be just what you need.

#blockchain #hyperledger #web3 #nft #business #businesses #token #tokenization #tokens #decentralized #p2p #entrepreneur #entrepreneurs #businesses #startup 

NFT Development Guide for Business Owners