先までは、"愛記"についての記載で、どのようにブロックチェーンSNSに組み込んで実装していけばよいのか、概念的なところからアプローチ方法を記載していった。大まかな概念としてはひとまず終えた。次は、ブロックチェーンの概念設計といえるところまで、基本設計書に着手できるようなところまで、概念を具体化していきたい。
愛記システムのシステム評価について
システム評価とは、つまりは、このシステムを導入して成功だったか失敗だったかという効果検証という意味だ。概念設計をする上で必ず抑えておくべきポイントということだ。それには各項目があり、それぞれの項目を見ていくことで、その結果が得られる。そのシステム評価項目を1つずつ見ていきたい。
システム構築の品質評価のポイント1：理解可能性（Understandability）
システム構築の品質評価のポイント2：完全性（Completeness）
システム構築の品質評価のポイント3：簡潔性（Conciseness）
システム構築の品質評価のポイント4：移植性（Portability）
システム構築の品質評価のポイント5：一貫性（Consistency）と構造化の度合い
システム構築の品質評価のポイント6：保守性（Maintainability）
システム構築の品質評価のポイント7：試験性（Testability）
システム構築の品質評価のポイント8：ユーザビリティ（Usability）
システム構築の品質評価のポイント9：効率性（Efficiency）
システム構築の品質評価のポイント10：セキュリティ（Security）
システム構築の品質評価のポイント6：保守性②（Maintainability）
システム構築の評価に繋がる保守性であるが、当方は、ブロックチェーンSNSとDapps側の愛記システムを、”愛貨”というトークンで創っていくということを考えている。そのために、APIによる通信ではなく、フェデレーションモデルを検討したい。
最初は一つの市町村における所得税減税や法人税減税サービスにつながるブロックチェーンSNSを考慮しているのだが、ゆくゆくは、他の市町村も同様に”愛貨”をやり取りするブロックチェーンSNSを導入したい！という声があがるだろう。さらには、世界中の各都市が同様に手をあげるかもしれない。そうなると、各市町村のブロックチェーンSNSが群雄割拠することになり、それらブロックチェーン間をブリッジして情報をやりとりすることも出てくるだろう。そうなると、各市町村のブロックチェーンを跨いで承認行為を行うようなフェデレーションモデルが必要になってくるということだ。
そして、フェデレーションが承認を行う際に、データやトランザクションにアクセスして必要な合意形成を行うことで、各市町村のブロックチェーンが提供する様々なサービスや機能を統合し、連携させる。このような仕組みを設けておけば、ある市町村のブロックチェーンSNSと、別の市町村のブロックチェーンSNSとを選択しながらユーザーは行動していけるということも可能となる。
”愛貨”をトークンとするブロックチェーンについて
Solanaの仕組みは魅力的であり、”愛貨”をトークンとする当方のブロックチェーンや愛記システムも同様な仕組みとすることを検討したい。Solanaは、トランザクションの処理にシャードやセカンドレイヤーを利用することなく、すべての処理がオンチェーンで行われるため、透明性が担保される。また、開発者やプログラムはSolanaの単一のグローバルな状態にアクセスできるため、プロジェクト間のコンポーザビリティが向上する。極めて保守性が高いといえる。”愛貨”もこのような状態を目指したい。
Proof of History (POH) — コンセンサスにおける時間同期。
Tower BFT — POHに最適化されたビザンチン将軍問題解決
Turbine — ブロックの伝搬プロトコル
Gulf Stream — Mempoolレスなトランザクションフォワードプロトコル
Sealevel — スマートコントラクトを並列で実行
Pipelining — 認証最適化のためのトランザクション処理ユニット
Cloudbreak — パラレルスケーリングのアカウントデータベース
Archivers — 分散型台帳保管
これらのアイデアはとても魅力的であり、愛記システムにもできる限り組み込んでいきたい。愛記システムにこれらの技術を組み込み、さらに、PoP（proof of Place)のアルゴリズムも加えたい。というのも、各市町村のブロックチェーンは、各市町村で愛の行動をしたという場所の証明が重要になる。その場所の座標データをPoPで組み込み、PoHで履歴とし、ブロックチェーンに保存していきたい。このようなアルゴリズム設計の例をプログラミング例で示してみよう。
# Gulf StreamのMempoolレスなトランザクションフォワードプロトコルの例
class GulfStream:
def __init__(self):
self.transactions = []
def add_transaction(self, transaction):
self.transactions.append(transaction)
def forward_transactions(self):
# トランザクションをフェデレーションに転送する処理
pass
# Turbineのブロックの伝搬プロトコルの例
class Turbine:
def __init__(self):
self.blocks = []
def add_block(self, block):
self.blocks.append(block)
def propagate_blocks(self):
# ブロックをネットワーク上で伝搬する処理
pass
# Proof of Place (PoP) の計算の例
import hashlib
def calculate_pop_proof(latitude, longitude):
location_data = f"Latitude: {latitude}, Longitude: {longitude}"
pop_proof = hashlib.sha256(location_data.encode()).hexdigest()
return pop_proof
# Proof of History (PoH) の例
class ProofOfHistory:
def __init__(self):
self.history = []
def add_to_history(self, data):
# データを履歴に追加する処理
self.history.append(data)
# 愛記システムの全体的なアーキテクチャ
class AiKiSystem:
def __init__(self):
self.gulf_stream = GulfStream()
self.turbine = Turbine()
self.proof_of_history = ProofOfHistory()
def process_transaction(self, transaction_data, latitude, longitude):
# トランザクションデータをGulf Streamに追加
self.gulf_stream.add_transaction(transaction_data)
# PoPの計算
pop_proof = calculate_pop_proof(latitude, longitude)
# PoHへの追加
self.proof_of_history.add_to_history(pop_proof)
def generate_block(self):
# トランザクションをブロックにまとめる処理
block_data = self.gulf_stream.transactions + self.proof_of_history.history
# ブロックをTurbineに追加
self.turbine.add_block(block_data)
# トランザクションと履歴をクリア
self.gulf_stream.transactions = []
self.proof_of_history.history = []
# 愛記システムのインスタンス生成
aiki_system = AiKiSystem()
# トランザクションの処理とブロック生成の例
aiki_system.process_transaction("Transaction1", 35.6895, 139.6917)
aiki_system.process_transaction("Transaction2", 37.7749, -122.4194)
aiki_system.generate_block()
これにはGulf StreamとTurbineという独自の機能があり、Proof of Place（PoP）とProof of History（PoH）も組み込まれている。より複雑にしていくには、いくつかの改善が必要であろう。
-
トランザクションとブロックのデータ構造:
- 現在の例では、トランザクションやブロックのデータはシンプルなリストに追加されている。これらのデータ構造をより構造的にし、トランザクションやブロックの属性（例: sender, receiver, timestamp）を考慮してみる必要がある。
-
ネットワークの同期:
- 分散環境で動作するようなブロックチェーンシステムでは、ネットワーク全体での同期が重要である。ブロックの伝搬やトランザクションの処理がネットワークに適切に伝わるように確認する必要がある。
-
トランザクションとブロックの署名:
- セキュリティ向上のために、トランザクションやブロックに署名機能を導入する必要がある。これにより、データの改ざんを防ぐことができる。
-
エラーハンドリング:
- 現在のコードではエラーハンドリングが考慮されていない。ネットワーク上での通信エラーやデータの不整合に対処できるようなエラーハンドリングを追加したい。
-
トランザクションのバッチ処理:
- 現在の例では、トランザクションを個別に処理している。効率を向上させるために、トランザクションのバッチ処理を考慮することも重要である。
-
PoPとPoHの拡張:
- PoPとPoHは十分にシンプルだが、より複雑な機能やセキュリティ検証を組み込むことも検討したい。
これらの提案を取り入れることで、より堅牢で効率的な愛記システムを構築できるのだろう。フェデレーションモデルも考慮して今一度、市町村のブロックチェーンのプログラムを記載すると、下記のようになる。
// 以下が最新の市町村のブロックチェーンのプログラム
use num_bigint::{BigUint, RandBigInt, ToBigUint};
use num_traits::{One, Zero};
use rand::thread_rng;
use sha2::{Sha256, Digest};
use std::collections::HashMap;
use std::time::{Duration, SystemTime};
use chrono::{Utc, DateTime};
use rand::seq::SliceRandom;
use hex;
// トークンタイプの定義
const TOKEN_TYPES: [&str; 10] = [
"AIR（Root）", "AIS（Sacral）", "AIP（Solar Plexus）", "AIH（Heart）",
"AIT（Throat）", "AII（Third Eye）", "AIC（Crown）", "AIU（Universal）",
"AIE（Earth Star）", "AIM（Solar Matrix）"
];
// Paillier暗号方式の鍵生成関数
fn generate_key() -> (BigUint, BigUint, BigUint) {
let p = 499.to_biguint().unwrap();
let q = 547.to_biguint().unwrap();
let n = &p * &q;
let lam = (&p - 1.to_biguint().unwrap()) * (&q - 1.to_biguint().unwrap());
let g = 2.to_biguint().unwrap();
(n, g, lam)
}
// Paillier暗号方式の暗号化関数
fn encrypt(m: &BigUint, n: &BigUint, g: &BigUint) -> BigUint {
let mut rng = thread_rng();
let r = rng.gen_biguint_below(n);
let n_squared = n * n;
(g.modpow(m, &n_squared) * r.modpow(n, &n_squared)) % &n_squared
}
// Paillier暗号方式の復号関数
fn decrypt(c: &BigUint, private_key: &(BigUint, BigUint, BigUint)) -> BigUint {
let (n, g, lam) = private_key;
let n_squared = n * n;
let x = c.modpow(lam, &n_squared) - 1.to_biguint().unwrap();
(x / n * g.modpow(&(lam.clone().mod_inverse(n).unwrap()), n) % n).modpow(&1.to_biguint().unwrap(), n)
}
// チャレンジ生成関数
fn generate_challenge() -> u32 {
rand::thread_rng().gen()
}
// 証明生成関数
fn generate_proof(secret: u32, challenge: u32) -> u32 {
secret + challenge
}
// 証明検証関数
fn verify_proof(proof: u32, challenge: u32, public_value: u32) -> bool {
proof == public_value + challenge
}
// トランザクション結果
#[derive(Debug)]
enum TransactionResult {
Success,
Failure,
}
// Verifiable Credentialの構造体
#[derive(Debug)]
struct VerifiableCredential {
user_id: String,
claim_data: HashMap<String, String>,
timestamp: SystemTime,
}
impl VerifiableCredential {
fn new(user_id: String, claim_data: HashMap<String, String>) -> Self {
VerifiableCredential {
user_id,
claim_data,
timestamp: SystemTime::now(),
}
}
}
// Blockchainトレイト
trait Blockchain {
fn store_credential(&self, credential: VerifiableCredential) -> Option<TransactionResult>;
fn update_shared_credential(&self, recipient_id: &str, credential: VerifiableCredential) -> Option<TransactionResult>;
fn select_block_producers(&self) -> Vec<String>;
}
// Blockchainのダミー実装
struct DummyBlockchain;
impl Blockchain for DummyBlockchain {
fn store_credential(&self, _credential: VerifiableCredential) -> Option<TransactionResult> {
Some(TransactionResult::Success)
}
fn update_shared_credential(&self, _recipient_id: &str, _credential: VerifiableCredential) -> Option<TransactionResult> {
Some(TransactionResult::Success)
}
fn select_block_producers(&self) -> Vec<String> {
vec!["Producer1".to_string(), "Producer2".to_string()]
}
}
// VerifiableCredentialManagerクラス
struct VerifiableCredentialManager {
blockchain: Box<dyn Blockchain>,
credentials: HashMap<String, VerifiableCredential>,
}
impl VerifiableCredentialManager {
fn new(blockchain: Box<dyn Blockchain>) -> Self {
VerifiableCredentialManager {
blockchain,
credentials: HashMap::new(),
}
}
fn create_verifiable_credential(&mut self, user_id: String, claim_data: HashMap<String, String>) {
let credential = VerifiableCredential::new(user_id.clone(), claim_data);
match self.blockchain.store_credential(credential.clone()) {
Some(TransactionResult::Success) => {
self.credentials.insert(user_id.clone(), credential);
println!("Verifiable Credential created and stored for user {}.", user_id);
},
_ => println!("Failed to store Verifiable Credential."),
}
}
fn share_verifiable_credential(&self, user_id: &str, recipient_id: &str) {
if let Some(credential_to_share) = self.credentials.get(user_id) {
match self.blockchain.update_shared_credential(recipient_id, credential_to_share.clone()) {
Some(TransactionResult::Success) => println!("Verifiable Credential shared with user {}.", recipient_id),
_ => println!("Failed to share Verifiable Credential."),
}
} else {
println!("No Verifiable Credential found for user {}.", user_id);
}
}
}
// ガルフストリーム機能の実装（仮の実装）
struct GulfStream;
impl GulfStream {
fn forward_transactions(&self, transactions: Vec<Transaction>) {
for transaction in transactions {
println!("Forwarding transaction: {:?}", transaction);
}
}
}
// LoveCurrency APIの実装
struct LoveCurrencyApi {
blockchain_client: DummyBlockchain,
federated_blockchains: HashMap<String, DummyBlockchain>,
}
impl LoveCurrencyApi {
fn new(blockchain_client: DummyBlockchain) -> Self {
LoveCurrencyApi {
blockchain_client,
federated_blockchains: HashMap::new(),
}
}
// メインチェーンから自治体のブロックチェーンにデータを送信するメソッド
fn send_data_to_municipality_chain(&self, transaction: &Transaction, municipality: &str) {
if transaction.verify_signature() {
println!("Sending data to municipality chain: {:?}", transaction);
// self.blockchain_client.send_transaction_to_municipality_chain(transaction, municipality); // 実際の送信ロジックを追加
println!("Data sent successfully.");
} else {
println!("Failed to send data: Invalid signature");
}
}
// 新しい自治体を登録するメソッド
fn register_new_municipality(&mut self, municipality_name: String) {
println!("Registering new municipality: {}", municipality_name);
self.federated_blockchains.insert(municipality_name, DummyBlockchain);
}
// APIの初期化処理
fn init() -> Self {
let dummy_blockchain = DummyBlockchain;
LoveCurrencyApi::new(dummy_blockchain)
}
// 新しいエンドポイントを追加して、リクエストを受け取ってからapprove_requestメソッドを呼び出す
fn approve_request_from_municipality(&self, data: &Transaction) {
if data.verify_signature() {
println!("Received approval request from municipality: {:?}", data);
// 実際には、リクエストを処理するロジックを実装する
} else {
println!("Failed to approve request: Invalid signature");
}
}
}
// トランザクションの構造体
#[derive(Debug)]
struct Transaction {
transaction_id: String,
municipality: String,
timestamp: SystemTime,
location: (f64, f64),
love_action_level: i32,
amount: f64,
action_content: String,
is_local: bool,
close_flag: bool,
approval_target: Option<String>,
sender_public_key: String,
receiver_public_key: String,
signature: String,
location_hash: Vec<u8>,
received_timestamp: Option<SystemTime>,
recipient_location: Option<(f64, f64)>,
fee: f64,
}
impl Transaction {
fn new(sender: &str, receiver: &str, location: &str, love_action_level: u32, action_content: &str, encrypted_data: Option<BigUint>) -> Self {
let transaction_id = Sha256::digest(&rand::thread_rng().gen::<[u8; 32]>()).to_vec();
Self {
transaction_id: hex::encode(transaction_id),
sender: sender.to_string(),
receiver: receiver.to_string(),
timestamp: Utc::now(),
location: location.to_string(),
love_action_level,
action_content: action_content.to_string(),
approval_target: None,
zero_knowledge_proof: None,
encrypted_data,
sender_exchange_count: 0,
receiver_exchange_count: 0,
}
}
fn generate_proof_of_place(&self) -> String {
format!("トランザクション {} の位置情報のPoPが生成されました: {}", self.transaction_id, self.location)
}
fn generate_proof_of_history(&self) -> String {
format!("トランザクション {} の履歴のPoHが生成されました: {}", self.transaction_id, self.timestamp)
}
fn generate_zero_knowledge_proof(&mut self) {
let (n, g, lam) = generate_key();
let m = rand::thread_rng().gen_range(1..n.clone());
let c = encrypt(&m, &n, &g);
let proof = format!("Zero Knowledge Proof for m: {}, c: {}", m, c);
self.zero_knowledge_proof = Some(proof);
}
fn transfer_token(&mut self, sender_level: u32, receiver_level: u32, total_exchanges: u32) -> Result<&str, &str> {
fn calculate_token_value(token_level: u32, exchange_count: u32, total_exchanges: u32) -> f64 {
let log_base = 1.0001;
let token_value = 0.001 * (token_level as f64) * (total_exchanges - exchange_count + 1) as f64 / (log_base.ln());
if token_level > 1 {
let previous_level_value = calculate_token_value(token_level - 1, exchange_count, total_exchanges);
return token_value.max(previous_level_value);
}
token_value
}
let sender_token_value = calculate_token_value(sender_level, self.sender_exchange_count, total_exchanges);
let receiver_token_value = calculate_token_value(receiver_level, self.receiver_exchange_count, total_exchanges);
if sender_level == receiver_level || sender_token_value >= receiver_token_value {
let token_type = TOKEN_TYPES[(sender_level - 1) as usize];
self.sender_exchange_count += 1;
self.receiver_exchange_count += 1;
Ok(token_type)
} else {
Err("Token transfer failed: Sender and receiver have different love action levels.")
}
}
fn decrypt_data(&self, private_key: &(BigUint, BigUint, BigUint)) -> Option<BigUint> {
if let Some(encrypted_data) = &self.encrypted_data {
Some(decrypt(encrypted_data, private_key))
} else {
None
}
}
}
fn calculate_location_hash(&mut self) {
let mut hasher = Sha256::new();
hasher.update(format!("{:?}", self.location));
self.location_hash = hasher.finalize().to_vec();
}
fn calculate_fee(&self) -> f64 {
self.amount * 0.01
}
fn display_fee(&self) {
let fee = self.calculate_fee();
println!("Transaction fee: {} 愛貨", fee);
}
fn generate_signature(&mut self) {
let message = format!(
"{}{}{:?}{}{}{}{}{:?}{}{}{}{}",
self.transaction_id,
self.municipality,
self.timestamp,
self.location.0,
self.location.1,
self.love_action_level,
self.amount,
self.location_hash,
self.sender_public_key,
self.receiver_public_key,
self.approval_target.clone().unwrap_or_default(),
self.signature,
);
let mut hasher = Sha256::new();
hasher.update(message);
self.signature = format!("{:x}", hasher.finalize());
}
fn verify_signature(&self) -> bool {
let message = format!(
"{}{}{:?}{}{}{}{}{:?}{}{}{}{}",
self.transaction_id,
self.municipality,
self.timestamp,
self.location.0,
self.location.1,
self.love_action_level,
self.amount,
self.location_hash,
self.sender_public_key,
self.receiver_public_key,
self.approval_target.clone().unwrap_or_default(),
self.signature,
);
let mut hasher = Sha256::new();
hasher.update(message);
let computed_signature = format!("{:x}", hasher.finalize());
self.signature == computed_signature
}
}
// DPoS構造体
struct DPoS {
municipalities: Vec<String>,
approved_representative: Option<String>,
}
impl DPoS {
fn new(municipalities: Vec<String>) -> Self {
Self {
municipalities,
approved_representative: None,
}
}
fn elect_representative(&mut self) -> String {
let representative = self.municipalities.choose(&mut rand::thread_rng()).unwrap().clone();
self.approved_representative = Some(representative.clone());
representative
}
fn approve_transaction(&self, transaction: &mut Transaction) -> Result<&str, &str> {
if let Some(representative) = &self.approved_representative {
transaction.approval_target = Some(representative.clone());
Ok("Transaction approved")
} else {
Err("No representative elected")
}
}
}
// Block構造体
#[derive(Debug)]
struct Block {
index: usize,
previous_hash: String,
timestamp: DateTime<Utc>,
data: Transaction,
proof_of_place: String,
proof_of_history: String,
zero_knowledge_proof: Option<String>,
hash: String,
}
impl Block {
fn new(index: usize, previous_hash: &str, data: Transaction) -> Self {
let timestamp = Utc::now();
let proof_of_place = data.generate_proof_of_place();
let proof_of_history = data.generate_proof_of_history();
let zero_knowledge_proof = data.zero_knowledge_proof.clone();
let hash = calculate_hash(index, previous_hash, ×tamp, &proof_of_place, &proof_of_history, &zero_knowledge_proof);
Self {
index,
previous_hash: previous_hash.to_string(),
timestamp,
data,
proof_of_place,
proof_of_history,
zero_knowledge_proof,
hash,
}
}
}
fn calculate_hash(index: usize, previous_hash: &str, timestamp: &DateTime<Utc>, proof_of_place: &str, proof_of_history: &str, zero_knowledge_proof: &Option<String>) -> String {
let mut hasher = Sha256::new();
hasher.update(index.to_string());
hasher.update(previous_hash);
hasher.update(timestamp.to_string());
hasher.update(proof_of_place);
hasher.update(proof_of_history);
if let Some(proof) = zero_knowledge_proof {
hasher.update(proof);
}
hex::encode(hasher.finalize())
}
// Blockchain構造体
struct Blockchain {
chain: Vec<Block>,
}
impl Blockchain {
fn new() -> Self {
let mut blockchain = Self { chain: Vec::new() };
blockchain.chain.push(Block::new(0, "0", Transaction::new("Genesis", "Genesis", "Genesis Location", 0, "Genesis Block", None)));
blockchain
}
fn get_latest_block(&self) -> &Block {
self.chain.last().unwrap()
}
fn add_block(&mut self, transaction: Transaction) {
let latest_block = self.get_latest_block();
let new_block = Block::new(self.chain.len(), &latest_block.hash, transaction);
self.chain.push(new_block);
}
}
// メイン関数
fn main() {
// APIの初期化
let mut api = LoveCurrencyApi::init();
// 新しい自治体の登録
api.register_new_municipality("MunicipalityA".to_string());
// トランザクションの作成
let mut transaction = Transaction::new("Alice", "Bob", "Location1", 8, "Action Content A", None);
transaction.generate_zero_knowledge_proof();
// データを自治体のチェーンに送信
api.send_data_to_municipality_chain(&transaction, "MunicipalityA");
// Verifiable Credentialのマネージャーの作成
let blockchain = Box::new(DummyBlockchain);
let mut vc_manager = VerifiableCredentialManager::new(blockchain);
// Verifiable Credentialの作成
let mut claim_data = HashMap::new();
claim_data.insert("Name".to_string(), "Alice".to_string());
vc_manager.create_verifiable_credential("user_id_123", claim_data);
// 全ブロックの表示
let mut blockchain = Blockchain::new();
blockchain.add_block(transaction);
println!("{:?}", blockchain.chain);
// Paillier暗号方式のテスト
let (n, g, lam) = generate_key();
let private_key = (n.clone(), g.clone(), lam.clone());
let message = 12345.to_biguint().unwrap();
println!("Original message: {}", message);
let encrypted_message = encrypt(&message, &n, &g);
println!("Encrypted message: {}", encrypted_message);
let decrypted_message = decrypt(&encrypted_message, &private_key);
println!("Decrypted message: {}", decrypted_message);
// ゼロ知識証明のテスト
let secret = 42; // 秘密値
let public_value = secret * 2; // 公開値
let challenge = generate_challenge();
let proof = generate_proof(secret, challenge);
println!("Public value: {}", public_value);
println!("Challenge: {}", challenge);
println!("Proof: {}", proof);
let is_valid = verify_proof(proof, challenge, public_value);
println!("Is proof valid? {}", is_valid);
// LoveCurrency APIのテスト
let mut api = LoveCurrencyApi::init();
let transaction = Transaction::new(
"txn123".to_string(),
"MunicipalityA".to_string(),
(36.2048, 138.2529),
5,
100.0,
"Love Action".to_string(),
true,
false,
"public_key_sender".to_string(),
"public_key_receiver".to_string(),
);
api.send_data_to_municipality_chain(&transaction, "MunicipalityA");
api.register_new_municipality("MunicipalityB".to_string());
// Verifiable Credential Managerのテスト
let mut vcm = VerifiableCredentialManager::new(Box::new(DummyBlockchain));
let mut claim_data = HashMap::new();
claim_data.insert("name".to_string(), "Alice".to_string());
claim_data.insert("age".to_string(), "30".to_string());
vcm.create_verifiable_credential("user123".to_string(), claim_data);
vcm.share_verifiable_credential("user123", "user456");
// Gulf Streamのテスト
let gulf_stream = GulfStream;
gulf_stream.forward_transactions(vec![transaction]);
}
この例では、フェデレーションがトランザクションを処理し、それらがメインチェーンのガルフストリームに転送され、最終的にメインチェーンでブロックが生成される。これにより、各市町村のブロックチェーンが独立して動作し、必要に応じてメインチェーンと連携できるようになる。フェデレーションモデルの流れを下記に記載しておく。
-
各市町村の独立ブロックチェーン:
- 各市町村は独自のブロックチェーンを持ち、それぞれのトランザクションを処理する。
- 各市町村のブロックチェーンは自治体内で完結するトランザクションを記録する。
-
トランザクションのメインチェーンへの転送:
- 市町村のブロックチェーンで発生したトランザクションのうち、他の市町村と関連するものや、全体の合意が必要なものはメインチェーンに転送される。
- ガルフストリーム（Gulf Stream）の機能を利用して、これらのトランザクションを効率的にメインチェーンに転送する。
-
メインチェーンでの処理:
- メインチェーンは受け取ったトランザクションを集約し、ブロックを生成する。
- この過程で、各トランザクションの検証や承認が行われる。
-
ブロック生成と同期:
- メインチェーンで生成されたブロックは、必要に応じて各市町村のブロックチェーンに反映される。
- これにより、全体の一貫性と信頼性が確保される。
いかがであろうか、Solanaの仕組みは魅力的であり、”愛貨”も同様な仕組みとすることを検討したい。Solanaは、トランザクションの処理にシャードやセカンドレイヤーを利用することなく、すべての処理がオンチェーンで行われるため、透明性が担保される。また、開発者やプログラムはSolanaの単一のグローバルな状態にアクセスできるため、プロジェクト間のコンポーザビリティが向上する。極めて保守性が高いといえる。”愛貨”もこのような状態を目指したい。