Exonumでブロックチェーンプロジェクトを作成する方法：クイックガイド

Exonumは、ブロックチェーンベースのアプリケーションを作成するためのオープンソースフレームワークです。 クローズドブロックチェーンでの作業に焦点を当てており、FinTech、GovTech、LegalTechなどのあらゆる分野に適用できます。



今日は、ソリューションの簡単なレビューを行い、教育形式の中で、Exonumで簡単なブロックチェーンベースのプロジェクトを構築する方法を見つけます。 以下のすべてのコードは、 GitHub のリポジトリにあります。





/ エキソナム。 ブロックチェーンへの次のステップ / Exonum

一言で言えばエクソン

Exonumフレームワークは、プライベートブロックチェーンの開発専用に作成されました。 これは、事前定義されたノードのグループのみがブロックチェーンに新しいブロックを作成できるシステムです。 Bitfuryの専門家の要望に基づいて、パブリックブロックチェーンに類似したプロパティ（信頼性、データの不変性、監査など）のシステムを比較的簡単に実行できるツールを作成しますが、保守と保守がより便利になります。



仮想分散マシンであり、世界中の多くのノードで同時に実行されるイーサリアムとは異なり、Exonumで構築されたブロックチェーンは、このシステムの動作に関心のある検証ノードの計算能力でのみ動作し、信頼性の高い動作を保証します。



所定のノードにデプロイされたExonumプライベートブロックチェーンは、少なくとも突然のハードフォーク、トランザクションプールの詰まり、およびオープンブロックチェーンに特有のその他の問題の可能性を排除し、ノードオペレーターはその有効な作業を監視します：トランザクション処理ルールの更新など



さらに、イーサリアムスマートコントラクトの実行は、暗号通貨の変動に大きく依存しています。イーサーレートは、たとえば、規制されていない「グレーゾーン」にある通貨での取引に支払いができない政府機関での使用を予測不能にします。 Exonumでは、このような依存関係は原則として存在しません。



最後に、Exonumブロックチェーンは、パブリックブロックチェーン（ビットコイン、イーサリアムなど）よりもはるかに高速に動作します。つまり、1秒あたり数千のトランザクションを処理します。 戦略の選択は、サイドチェーンテクノロジーを介して相互に作用する多数の独立したブロックチェーンを作成し、パブリックブロックチェーンにリンク（アンカー）するなどの一般的な傾向によるものです。



Exonumの主要コンポーネントは、ビザンチンコンセンサス、ライトクライアント、ビットコインバインディングおよびサービスです。



システムは、 特別なビザンチン合意アルゴリズムを使用して、ノード間でデータを同期します。 ブロックマイニングを必要とせずに、誤動作や意図的な悪意のあるアクティビティによる最大1/3ノードの障害が発生した場合でも、データの整合性とトランザクションの正しい実行を保証します。



Exonumの既存のアナログに対する利点について言えば、開発されたデータモデル（ストレージ）に注目できます。これは、相互の依存関係（本質的にはテーブル）を含むインデックスです。特定の問題を解決するための効果的なデータ構造を実装できます。 このようなブロックチェーンのクライアントは、ダウンロードされたデータ（Merkleツリー）の正確性の暗号化された証拠を受け取ることができ、クライアントのマシンでローカルにチェックされ、Exonumノードのオペレーターでさえ偽造することはできません。



ライトクライアントは、対象のブロックチェーンのごく一部のみをホストするネットワークノードです。 モバイルアプリケーションまたはWebブラウザーを使用してブロックチェーンと対話できます。 クライアントは、APIを介して完全に機能するノードで1つ以上のサービスと「通信」します 。 このようなシンクライアントの作業は、個々のサービスに固有であり、特定のサービスが必要とするほど困難に実装されます。



Exonumシンクライアントと連携してエビデンスを構築することの本質は、ビットコインブロックチェーンにリンクしているエンドユーザーがプライベートブロックチェーンのオペレーターを信頼できない可能性があることです。 しかし、彼が表示するデータは、この特定のプライベートブロックチェーンで規定されているルールに従って取得されていることを確認できます。



Exonumのライトクライアントのセキュリティは、permissionless-blockchainに匹敵するものであり、前述のビットコインへのバインド、いわゆるアンカーリングによって保証されています。 サービスは、トランザクション証明書の形式で、ブロックハッシュをパブリックビットコインブロックチェーンに定期的に送信します。 この場合、Exonumブロックチェーンが機能しなくなっても、データを検証できます。 さらに、このようなネットワークを攻撃するには、攻撃者は両方のブロックチェーンの保護メカニズムを克服する必要があり、これには非常に大きな計算能力が必要です。



そして最後に、サービスはExonumフレームワークの基盤です 。 他のプラットフォーム上のスマートコントラクトに似ており、ブロックチェーンアプリケーションのビジネスロジックが含まれています。 ただし、スマートコントラクトとは異なり、Exonumのサービスは仮想マシンで「ロック」されておらず、コンテナ化されていません。



これにより、より効率的かつ柔軟になります。 ただし、このアプローチでは、プログラミング時にさらに注意が必要です（サービスの分離はExonumロードマップでマークされています）。 サービスはトランザクションを処理するためのルールを決定し、データへのアクセスを外部クライアントに提供します 。



主要なコンポーネントに精通しているので、例の分析に進むことができます。

Exonumでのサービスの作成

Exonumバージョン0.3のリリースは11月2日に行われ、追加のガイドはシステムの変更と改善を考慮して書かれています（GitHubのリポジトリで確認できます）。 暗号通貨を実装する1つのノードでブロックチェーンを作成します。 ネットワークは、「ウォレットを作成する」と「1つのウォレットから別のウォレットに資金を転送する」という2種類のトランザクションを受け入れます。



ExonumはRustで記述されているため、コンパイラをインストールする必要があります。 これを行うには、 ガイドを使用できます。

ノード作成

まず、新しいクレートを作成します：

cargo new --bin cryptocurrency
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして、作成されたcargo.tomlに必要な依存関係を追加します 。

 [package] name = "cryptocurrency" version = "0.3.0" authors = ["Your Name <your@email.com>"] [dependencies] iron = "0.5.1" bodyparser = "0.7.0" router = "0.5.1" serde = "1.0" serde_json = "1.0" serde_derive = "1.0" exonum = "0.3.0"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

必要なタイプのクレートをインポートします。 これを行うには、src / main.rsファイルを編集します 。

 extern crate serde; extern crate serde_json; #[macro_use] extern crate serde_derive; #[macro_use] extern crate exonum; extern crate router; extern crate bodyparser; extern crate iron; use exonum::blockchain::{Blockchain, Service, GenesisConfig, ValidatorKeys, Transaction, ApiContext}; use exonum::node::{Node, NodeConfig, NodeApiConfig, TransactionSend, ApiSender }; use exonum::messages::{RawTransaction, FromRaw, Message}; use exonum::storage::{Fork, MemoryDB, MapIndex}; use exonum::crypto::{PublicKey, Hash, HexValue}; use exonum::encoding::{self, Field}; use exonum::api::{Api, ApiError}; use iron::prelude::*; use iron::Handler; use router::Router;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

定数を定義します。

 // Service identifier const SERVICE_ID: u16 = 1; // Identifier for wallet creation transaction type const TX_CREATE_WALLET_ID: u16 = 1; // Identifier for coins transfer transaction type const TX_TRANSFER_ID: u16 = 2; // Starting balance of a newly created wallet const INIT_BALANCE: u64 = 100;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして主な機能：

 fn main() { exonum::helpers::init_logger().unwrap(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、コンソールにExonumノードのアクティビティに関する情報を表示するロガーを設定できます。



ブロックチェーン自体を形成するには、データベースインスタンス（この場合はMemoryDBですが、RocksDBを使用することもできます）を作成し、 サービスのリストを宣言する必要があります 。 ロガーを初期化した後にこのコードを配置します。

 let db = MemoryDB::new(); let services: Vec<Box<Service>> = vec![ ]; let blockchain = Blockchain::new(Box::new(db), services);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

基本的に、ブロックチェーンは準備ができていますが、動作しません-それにアクセスするためのノードとAPIがまだありません。 ノードを構成する必要があります 。 構成では、 バリデーターの公開キーのリストを指定します（この例では1つになります）。 実際、各ノードには、公開鍵と秘密鍵の2つのペアが必要です。1つはコンセンサスに達する過程で他のノードと対話するためのもので、もう1つはサービス用です。 この例では、 exonum :: crypto :: gen_keypair（）コマンドで一時公開キーを作成し、構成ファイルに書き込みます。

 let validator_keys = ValidatorKeys { consensus_key: consensus_public_key, service_key: service_public_key, }; let genesis = GenesisConfig::new(vec![validator_keys].into_iter());
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、外部Webリクエストを処理するためのREST APIを設定します。このためにポート8000​​を開きます。また、Exonumネットワークのフルノードが相互に通信できるようにポート2000を開きます。

 let api_address = "0.0.0.0:8000".parse().unwrap(); let api_cfg = NodeApiConfig { public_api_address: Some(api_address), ..Default::default() }; let peer_address = "0.0.0.0:2000".parse().unwrap(); // Complete node configuration let node_cfg = NodeConfig { listen_address: peer_address, peers: vec![], service_public_key, service_secret_key, consensus_public_key, consensus_secret_key, genesis, external_address: None, network: Default::default(), whitelist: Default::default(), api: api_cfg, mempool: Default::default(), services_configs: Default::default(), }; let node = Node::new(blockchain, node_cfg); node.run().unwrap();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

データを宣言する

この段階で、ブロックチェーンに保存するデータを決定する必要があります。 私たちの場合、これはウォレットと残高に関する情報、ウォレット所有者からのリクエストをチェックするための公開鍵、所有者の名前です。 構造は次のようになります。

 encoding_struct! { struct Wallet { const SIZE = 48; field pub_key: &PublicKey [00 => 32] field name: &str [32 => 40] field balance: u64 [40 => 48] } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

マクロencoding_struct！ 順序付けられた構造を宣言し、値フィールドの境界をマークするのに役立ちます。 ウォレットの残高を変更する必要があるため、ウォレットにメソッドを追加します ：

 impl Wallet { pub fn increase(self, amount: u64) -> Self { let balance = self.balance() + amount; Self::new(self.pub_key(), self.name(), balance) } pub fn decrease(self, amount: u64) -> Self { let balance = self.balance() - amount; Self::new(self.pub_key(), self.name(), balance) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

また、MemoryDBにキーと値のストレージを作成する必要があります。 これを行うには、フォークを使用して、最後の手段としてすべての変更をロールバックできます。

 pub struct CurrencySchema<'a> { view: &'a mut Fork, }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、フォークはデータベース内のすべての情報へのアクセスを許可します。 ウォレットを分離するには、一意のプレフィックスを追加し、 MapIndex抽象マップを使用します 。

 impl<'a> CurrencySchema<'a> { pub fn wallets(&mut self) -> MapIndex<&mut Fork, PublicKey, Wallet> { let prefix = blockchain::gen_prefix(SERVICE_ID, 0, &()); MapIndex::new("cryptocurrency.wallets", self.view) } // Utility method to quickly get a separate wallet from the storage pub fn wallet(&mut self, pub_key: &PublicKey) -> Option<Wallet> { self.wallets().get(pub_key) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

トランザクションを定義します

すでに述べたように、この教育的な例の操作には、ウォレットを作成して資金を追加し、それらを別のウォレットに転送するという次のタイプのトランザクションが必要です。



ウォレットを作成するトランザクションには、公開鍵とユーザー名が含まれている必要があります。

 message! { struct TxCreateWallet { const TYPE = SERVICE_ID; const ID = TX_CREATE_WALLET_ID; const SIZE = 40; field pub_key: &PublicKey [00 => 32] field name: &str [32 => 40] } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ウォレットを作成する前に、その一意性を確認します。 100コインもクレジットします。

 impl Transaction for TxCreateWallet { fn verify(&self) -> bool { self.verify_signature(self.pub_key()) } fn execute(&self, view: &mut Fork) { let mut schema = CurrencySchema { view }; if schema.wallet(self.pub_key()).is_none() { let wallet = Wallet::new(self.pub_key(), self.name(), INIT_BALANCE); println!("Create the wallet: {:?}", wallet); schema.wallets().put(self.pub_key(), wallet) } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

送金のトランザクションは次のようになります。

 message! { struct TxTransfer { const TYPE = SERVICE_ID; const ID = TX_TRANSFER_ID; const SIZE = 80; field from: &PublicKey [00 => 32] field to: &PublicKey [32 => 64] field amount: u64 [64 => 72] field seed: u64 [72 => 80] } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2つの公開鍵が（両方のウォレットに対して）そこにマークされ、転送されるコインの数。 トランザクションを繰り返すことができないように 、 シードフィールドが追加されます。 また、送信者が自分に資金を送っていないことを確認する必要があります。

 impl Transaction for TxTransfer { fn verify(&self) -> bool { (*self.from() != *self.to()) && self.verify_signature(self.from()) } fn execute(&self, view: &mut Fork) { let mut schema = CurrencySchema { view }; let sender = schema.wallet(self.from()); let receiver = schema.wallet(self.to()); if let (Some(mut sender), Some(mut receiver)) = (sender, receiver) { let amount = self.amount(); if sender.balance() >= amount { let sender.decrease(amount); let receiver.increase(amount); println!("Transfer between wallets: {:?} => {:?}", sender, receiver); let mut wallets = schema.wallets(); wallets.put(self.from(), sender); wallets.put(self.to(), receiver); } } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

トランザクションがブロックチェーンブロックエクスプローラーで正しく表示されるようにするには、 `info（）`メソッドを再定義する必要もあります。 実装は両方のタイプのトランザクションで同じであり、次のようになります。

 impl Transaction for TxCreateWallet { // `verify()` and `execute()` code... fn info(&self) -> serde_json::Value { serde_json::to_value(&self) .expect("Cannot serialize transaction to JSON") } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

トランザクションAPIを実装します

これを行うには、チャネルとブロックチェーンインスタンスを含む構造を作成します。これは、読み取り要求を実装するために必要です。

 #[derive(Clone)] struct CryptocurrencyApi { channel: ApiSender, blockchain: Blockchain, }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

プロセスの処理を簡素化するために、 TransactionRequest enumを追加します。これは、「ウォレットの作成」と「資金の転送」の両方のタイプのトランザクションを組み合わせます。

 #[serde(untagged)] #[derive(Clone, Serialize, Deserialize)] enum TransactionRequest { CreateWallet(TxCreateWallet), Transfer(TxTransfer), } impl Into<Box<Transaction>> for TransactionRequest { fn into(self) -> Box<Transaction> { match self { TransactionRequest::CreateWallet(trans) => Box::new(trans), TransactionRequest::Transfer(trans) => Box::new(trans), } } } #[derive(Serialize, Deserialize)] struct TransactionResponse { tx_hash: Hash, }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ハンドラーをWebサーバーのHTTPハンドラーと「友達にする」ことは変わりません。 これを行うには、 wireメソッドを実装します。 以下の例では、JSON入力をトランザクションに変換するハンドラーを追加します。

 impl Api for CryptocurrencyApi { fn wire(&self, router: &mut Router) { let self_ = self.clone(); let tx_handler = move |req: &mut Request| -> IronResult<Response> { match req.get::<bodyparser::Struct<TransactionRequest>>() { Ok(Some(tx)) => { let tx: Box<Transaction> = tx.into(); let tx_hash = tx.hash(); self_.channel.send(tx).map_err(ApiError::from)?; let json = TransactionResponse { tx_hash }; self_.ok_response(&serde_json::to_value(&json).unwrap()) } Ok(None) => Err(ApiError::IncorrectRequest( "Empty request body".into()))?, Err(e) => Err(ApiError::IncorrectRequest(Box::new(e)))?, } }; // (Read request processing skipped) // Bind the transaction handler to a specific route. router.post("/v1/wallets/transaction", transaction, "transaction"); // (Read request binding skipped) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

読み取り要求用のAPIを実装します

トランザクションが実際に実行されていることを確認できるように、システムのすべてのウォレットに関する情報を返す、および公開キーに対応する特定のウォレットに関する情報のみを返すという2種類の読み取り要求を実装します。



これを行うには、ブロックチェーンフィールドにアクセスしてブロックチェーンストレージから情報を読み取るCryptocurrencyApiのメソッドをいくつか定義します。

 impl CryptocurrencyApi { fn get_wallet(&self, pub_key: &PublicKey) -> Option<Wallet> { let mut view = self.blockchain.fork(); let mut schema = CurrencySchema { view: &mut view }; schema.wallet(pub_key) } fn get_wallets(&self) -> Option<Vec<Wallet>> { let mut view = self.blockchain.fork(); let mut schema = CurrencySchema { view: &mut view }; let idx = schema.wallets(); let wallets: Vec<Wallet> = idx.values().collect(); if wallets.is_empty() { None } else { Some(wallets) } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、データへの書き込みおよび読み取りアクセスを与えるという事実にもかかわらず（この例が過負荷にならないように）、forkメソッドを使用するという事実に注意を払う価値があります。 実際の状態では、読み取り専用のアクセス形式（スナップショットを参照）を使用することをお勧めします。



さらに、トランザクションについては、 CryptocurrencyApi :: wire（）のget_wallets（）およびget_wallet（） メソッドを使用してリクエスト処理を追加します。

 impl Api for CryptocurrencyApi { fn wire(&self, router: &mut Router) { let self_ = self.clone(); // (Transaction processing skipped) // Gets status of all wallets in the database. let self_ = self.clone(); let wallets_info = move |_: &mut Request| -> IronResult<Response> { if let Some(wallets) = self_.get_wallets() { self_.ok_response(&serde_json::to_value(wallets).unwrap()) } else { self_.not_found_response( &serde_json::to_value("Wallets database is empty") .unwrap(), ) } }; // Gets status of the wallet corresponding to the public key. let self_ = self.clone(); let wallet_info = move |req: &mut Request| -> IronResult<Response> { // Get the hex public key as the last URL component; // return an error if the public key cannot be parsed. let path = req.url.path(); let wallet_key = path.last().unwrap(); let public_key = PublicKey::from_hex(wallet_key) .map_err(ApiError::FromHex)?; if let Some(wallet) = self_.get_wallet(&public_key) { self_.ok_response(&serde_json::to_value(wallet).unwrap()) } else { self_.not_found_response( &serde_json::to_value("Wallet not found").unwrap(), ) } }; // (Transaction binding skipped) // Bind read request endpoints. router.get("/v1/wallets", wallets_info, "wallets_info"); router.get("/v1/wallet/:pub_key", wallet_info, "wallet_info"); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サービスを定義する

CurrencyService構造をブロックチェーンサービスに変えるには、Serviceプロパティをそれに割り当てる必要があります。 サービスの名前を返すservice_nameと 、一意のIDを返すservice_idの 2つのメソッドがあります。

tx_from_rawメソッドは、トランザクションの逆シリアル化に使用され、 public_api_handlerメソッドは、サイトへのWeb要求を処理するためのRESTハンドラーの作成に使用されます。 CryptocurrencyApiで既に定義されているロジックを適用します。

 impl Service for CurrencyService { fn service_name(&self) -> &'static str { "cryptocurrency" } fn service_id(&self) -> u16 { SERVICE_ID } fn tx_from_raw(&self, raw: RawTransaction) -> Result<Box<Transaction>, encoding::Error> { let trans: Box<Transaction> = match raw.message_type() { TX_TRANSFER_ID => Box::new(TxTransfer::from_raw(raw)?), TX_CREATE_WALLET_ID => Box::new(TxCreateWallet::from_raw(raw)?), _ => { return Err(encoding::Error::IncorrectMessageType { message_type: raw.message_type() }); }, }; Ok(trans) } fn public_api_handler(&self, ctx: &ApiContext) -> Option<Box<Handler>> { let mut router = Router::new(); let api = CryptocurrencyApi { channel: ctx.node_channel().clone(), blockchain: ctx.blockchain().clone(), }; api.wire(&mut router); Some(Box::new(router)) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ミニブロックチェーンのすべての部分を実装しました。 ここで、ブロックチェーンサービスのリストにCryptocyrrencyServiceを追加してデモを実行します。

 let services: Vec<Box<Service>> = vec![ Box::new(CurrencyService), ]; cargo run
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サービステスト

Exonumを使用すると、サービスの動作をテストできます。 これを行うには、Sandboxパッケージを使用します-ネットワークをシミュレートします。 ノードにリクエストを送信してレスポンスを受信し、ブロックチェーンで発生する変更を観察できます。 Sandboxインスタンスはsandbox_with_servicesメソッドによって作成され、テスト用のサービスを指定できます。 たとえば、次のように：

 let s = sandbox_with_services(vec![Box::new(CurrencyService::new()), Box::new(ConfigUpdateService::new())]);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

一般に、Sandboxはホストがメッセージを受信するプロセスをシミュレートし、どのホストがメッセージを送信し、何がその中にあったかを確認できます。 また、「サンドボックス」は時間とともに機能します。たとえば、任意の期間の有効期限をシミュレートします。

トランザクション送信

では、ブロックチェーンデモでいくつかのトランザクションを送信してみましょう。 まず、ウォレットを作成します。 create-wallet-1.jsonファイルは次のようになります。

 { "body": { "pub_key": "03e657ae71e51be60a45b4bd20bcf79ff52f0c037ae6da0540a0e0066132b472", "name": "Johnny Doe" }, "network_id": 0, "protocol_version": 0, "service_id": 1, "message_id": 1, "signature": "ad5efdb52e48309df9aa582e67372bb3ae67828c5eaa1a7a5e387597174055d315eaa7879912d0509acf17f06a23b7f13f242017b354f682d85930fa28240402" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

curlコマンドを使用して、HTTPを介してトランザクションを送信します。

 curl -H "Content-Type: application/json" -X POST -d @create-wallet-1.json \ http://127.0.0.1:8000/api/services/cryptocurrency/v1/wallets/transaction
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

その後、コンソールでウォレットが作成されたことを確認できます。

 Create the wallet: Wallet { pub_key: PublicKey(3E657AE), name: "Johnny Doe", balance: 100 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2番目のウォレットも同じように形成されます。 作成後、資金を転送できます。 transfer-funds.jsonファイルは次のようになります 。

 { "body": { "from": "03e657ae71e51be60a45b4bd20bcf79ff52f0c037ae6da0540a0e0066132b472", "to": "d1e877472a4585d515b13f52ae7bfded1ccea511816d7772cb17e1ab20830819", "amount": "10", "seed": "12623766328194547469" }, "network_id": 0, "protocol_version": 0, "service_id": 1, "message_id": 2, "signature": "2c5e9eee1b526299770b3677ffd0d727f693ee181540e1914f5a84801dfd410967fce4c22eda621701c2b9c676ed62bc48df9c973462a8514ffb32bec202f103" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このトランザクションは、10個のコインを最初のウォレットから2番目のウォレットに転送します。 curlを使用してコマンドをノードに送信します。

 curl -H "Content-Type: application/json" -X POST -d @transfer-funds.json \ http://127.0.0.1:8000/api/services/cryptocurrency/v1/wallets/transaction
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ノードは、金額が正常に転送されたことを示します。

 Transfer between wallets: Wallet { pub_key: PublicKey(3E657AE), name: "Johnny Doe", balance: 90 } => Wallet { pub_key: PublicKey(D1E87747), name: "Janie Roe", balance: 110 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、読み取り要求処理エンドポイントが実際に機能することを確認しましょう。 次のように、システム内の両方のウォレットのステータスをリクエストできます。

 curl http://127.0.0.1:8000/api/services/cryptocurrency/v1/wallets
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このリクエストは、ウォレットに関する情報を次の形式で提供します。

 [ { "balance": "90", "name": "Johnny Doe", "pub_key": "03e657ae71e51be60a45b4bd20bcf79ff52f0c037ae6da0540a0e0066132b472" }, { "balance": "110", "name": "Janie Roe", "pub_key": "d1e877472a4585d515b13f52ae7bfded1ccea511816d7772cb17e1ab20830819" } ]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2番目のエンドポイントも機能します。 これを確認するには、次のリクエストを送信します。

 curl "http://127.0.0.1:8000/api/services/cryptocurrency/v1/wallet/\ 03e657ae71e51be60a45b4bd20bcf79ff52f0c037ae6da0540a0e0066132b472"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

答えが得られます。

 { "balance": "90", "name": "Johnny Doe", "pub_key": "03e657ae71e51be60a45b4bd20bcf79ff52f0c037ae6da0540a0e0066132b472" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

したがって、教材の一部として、単純なブロックチェーンが1つのバリデーターとどのように機能するかを見つけました。 次の投稿では、Exonumのブロックチェーンバインディング、ノード管理、コンセンサスについて詳しく説明します。