先までは、"愛記"についての記載で、どのようにブロックチェーンSNSに組み込んで実装していけばよいのか、概念的なところからアプローチ方法を記載していった。大まかな概念としてはひとまず終えた。次は、ブロックチェーンの概念設計といえるところまで、基本設計書に着手できるようなところまで、概念を具体化していきたい。
次元について②
導入に際しては、各次元ごとを生命体として捉えることにし、それぞれの生命体を機能させるために、自分がやるべき事という視点で導入していけば良い。
・１次元：個人という生命体
・２次元：部署・チームという生命体
・３次元：会社という生命体
・４次元：業界・団体という生命体
・５次元：産業という生命体
・６次元：日本経済という生命体
・７次元：世界経済という生命体
・８次元：人類という生命体
・９次元：地球という生命体
・１０次元：太陽系という生命体
これらの生命体を日々、思考・意識で捉えていき、機能しているかどうかを定期的にチェックしていくということを皆にやってもらうということだ。このような思考・意識の型を世界中に広め、世界の人々が”型”を競い合うようになると当方は思っている。何せ、世の中は、従来のサプライチェーンマネジメントという１：１という手法から、プラットフォームビジネスという１：∞という手法へと変わりつつあるのだから。ありとあらゆる分野で直接エンドユーザーと対峙するビジネスに変わりつつあるのだから。
さて、話を前回の続きに戻すと、同じ次元でしか愛貨を受け取れないというルールは、シンプルで理解しやすく、実装も比較的容易である。このルールによって、異なる次元での混乱や誤解を避けることができ、システム全体の安定性を高めることができる。ただし、異なる次元での愛貨の受け取りを許可することで、より多様なコミュニケーションや交流が生まれる可能性もある。このような側面も考慮しながら、システムの設計や目的に合わせてルールを検討すると良い。具体的な設計ポイントを示すと、次のような考え方が挙げられる。
-
自由度の確保：
- 受け取り側が選択できる次元を増やすことで、自由度を高める。
- 各次元での受け取りに対応するため、柔軟なデータ構造やアルゴリズムを採用する。
-
使いやすさの確保：
- ユーザーが簡単に次元を選択できるよう、直感的なインターフェースを提供する。
- デフォルト設定で自動的に最適な次元が選択されるようにすることで、ユーザーの負担を軽減する。
-
セキュリティの確保：
- 次元の選択が適切であるかを確認するため、トランザクションに対する適切な検証手段を備える。
- ユーザーが意図しない次元でのトランザクションが発生しないよう、適切な制御措置を講じる。
-
バランスの調整：
- 自由度と使いやすさ、セキュリティのバランスを保つため、設計段階からこれらの要素をトレードオフとして考慮する。
- ユーザーが自由度を享受しつつ、システムが安全で使いやすい状態を維持するために、適切な配慮が必要となる。
これらのポイントを踏まえて、システム設計を行うことで、自由度と使いやすさ、セキュリティのバランスを取りながら、効果的なシステムを構築することが可能である。
設計として、まずデフォルトは送信者と同じ次元で同じレベルの愛貨トークンを受け取るということ。次元を変更したい場合は、少なくとも1回以上愛貨をやりとりした事がある次元の生命体に限り、選択肢にリスト表記させる。このような仕組みにしたい。受け取り側が各次元で受け取れるとしても、実際には自分の次元に合った受け取りをすることが多いという想定だ。この考え方は理解できるだろう。次元が高くなるほど、その行動や意識が求められることが増えるため、次に自分が実際に高い次元で行動せねばならないことを考えると、自分の次元に合った受け取りをすることになるのだろう。
-
デフォルトは同じ次元での受け取り：受け取り側が自分と同じ次元で受け取ることが多いということを考慮し、デフォルトでは同じ次元での受け取りを想定して設計することが重要である。
-
任意の次元での受け取りをサポート：一方で、受け取り側が特定の行動や意識を持って異なる次元で受け取ることを選択できるようにすることも重要である。自由度を高めることで、意識の成長や行動の多様性を促進できる。
-
バランスの取れた設計：システム設計では、自由度と使いやすさ、セキュリティのバランスを取ることが大切である。受け取り側が適切な次元で受け取れるようにしつつ、シンプルで使いやすいインターフェースを提供することが理想的である。
-
ユーザーの意図を尊重：最終的には、ユーザーの意図や行動パターンを理解し、それに合わせてシステムを適切に機能させることが重要である。ユーザーが自然な形でシステムを利用できるように心がける。
このような観点から、システムの設計や実装を進めていくと良いのだろう。
DApps側であるバックエンドプログラム
以下に、この仕組みを実現するためのDApps側のPythonプログラムの例を示す。この例では、Dimensionクラスを導入して、各次元の生命体がやり取りした履歴を保持する。また、トランザクションを送信する際に、送信者の次元が履歴に含まれているかを確認している。
from flask import Flask, jsonify, request
from datetime import datetime
import hashlib
import json
import random
app = Flask(__name__)
class Transaction:
def __init__(self, sender, receiver, amount, sender_dimension):
self.sender = sender
self.receiver = receiver
self.amount = amount
self.timestamp = datetime.now()
self.sender_dimension = sender_dimension
def to_dict(self):
return {
'sender': self.sender,
'receiver': self.receiver,
'amount': self.amount,
'timestamp': str(self.timestamp)
}
def __repr__(self):
return f"Transaction(sender={self.sender}, receiver={self.receiver}, amount={self.amount}, timestamp={self.timestamp})"
class Dimension:
def __init__(self):
self.history = {}
def add_history(self, dimension, user_id):
if dimension not in self.history:
self.history[dimension] = set()
self.history[dimension].add(user_id)
def has_history(self, dimension, user_id):
return dimension in self.history and user_id in self.history[dimension]
class Blockchain:
def __init__(self):
self.chain = []
self.pending_transactions = []
self.create_block(proof=0, previous_hash='0')
self.dimension = Dimension() # 次元の履歴を管理するインスタンス
def create_block(self, proof, previous_hash=None):
block = Block(index=len(self.chain) + 1, proof=proof, previous_hash=previous_hash or self.chain[-1].hash if self.chain else '0', transactions=self.pending_transactions)
self.chain.append(block)
self.pending_transactions = []
return block
def add_transaction(self, sender, receiver, amount, sender_dimension):
if not self.dimension.has_history(sender_dimension, sender):
return False, "Sender has no transaction history in this dimension"
self.pending_transactions.append(Transaction(sender, receiver, amount, sender_dimension))
return True, f"Transaction will be added to Block {self.last_block.index + 1}"
@property
def last_block(self):
return self.chain[-1]
def hash(self, block):
block_string = json.dumps(block.to_dict(), sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
def is_chain_valid(self, chain):
previous_block = chain[0]
current_index = 1
while current_index < len(chain):
block = chain[current_index]
if block.previous_hash != self.hash(previous_block):
return False
previous_block = block
current_index += 1
return True
# テスト用のデモ
blockchain = Blockchain()
# トークンの送受信
blockchain.dimension.add_history(1, "Alice") # Aliceが次元1でトランザクションを行った履歴を追加
blockchain.add_transaction("Alice", "Bob", 50, 1) # 次元1でトランザクションを行う
# APIのエンドポイント
@app.route('/user_data', methods=['GET'])
def get_user_data():
user_id = request.args.get('user_id') # ユーザーIDを取得
# ユーザーIDを元に、ユーザーのデータを取得
# 以下は仮のデータです
dimension_history = blockchain.dimension.history.get(1, []) # 次元1の履歴を取得
available_dimensions = list(filter(lambda x: blockchain.dimension.has_history(x, user_id), dimension_history))
user_data = {
'user_id': user_id,
'available_dimensions': available_dimensions,
'transactions': [tx.to_dict() for block in blockchain.chain for tx in block.transactions if tx.sender == user_id or tx.receiver == user_id]
}
return jsonify(user_data)
if __name__ == '__main__':
app.run(debug=True)
修正点は以下のとおりだ。
-
Dimensionクラスにavailable_dimensionsを追加した。これは、各次元の生命体が一度でも愛貨をやり取りしたことがある次元のリストを保持する。
-
get_user_data関数では、送信者の次元が選択可能な次元のリストに含まれているかどうかを確認する。具体的には、available_dimensionsに対してfilter関数を使って送信者の次元が含まれているかどうかをチェックし、結果をavailable_dimensionsに再設定する。
-
修正後のプログラムでは、送信者が次元を選択する際に、一度でも愛貨をやり取りしたことがある次元の生命体のみが選択可能となる。これにより、次元の選択が制限される仕組みが実装された。
修正後のプログラムでは、次元を選択する際に、送信者の次元が選択可能な次元のリストに含まれているかどうかを確認することで、次元の選択が制限されるようになった。
DApps側であるフロントエンドプログラム
const dimensionSelect = document.getElementById('dimension-select');
const csrfToken = document.getElementById('csrf-token').getAttribute('content');
async function getDimensions() {
const response = await fetch('/dimensions', {
method: 'GET',
headers: {
'Content-Type': 'application/json',
'X-CSRFToken': csrfToken
},
});
if (!response.ok) {
throw new Error(`Failed to fetch dimensions: ${response.status}`);
}
return await response.json();
}
async function displayDimensions() {
try {
const dimensions = await getDimensions();
const senderDimension = 1; // 例: 送信者の次元が1とする
let dimensionChoices = dimensions[senderDimension];
// 更なる選択肢（一度でも愛貨をやり取りしたことがある次元の生命体）を取得
const moreDimensionChoices = dimensions[senderDimension];
// 更なる選択肢を現在の選択肢に追加
dimensionChoices = dimensionChoices.concat(moreDimensionChoices);
// 重複を除去して最終的な選択肢を取得
dimensionChoices = [...new Set(dimensionChoices)];
// 選択肢を表示
dimensionChoices.forEach(dim => {
const option = document.createElement('option');
option.value = dim;
option.textContent = dim;
dimensionSelect.appendChild(option);
});
} catch (error) {
console.error(`Error: ${error.message}`);
}
}
document.getElementById('get-dimensions-btn').addEventListener('click', displayDimensions);
ブロックチェーン側のプログラム
下記の修正により、transfer_tokenメソッドはトークンの転送を行う際に、選ばれた愛貨のレベルと次元を受け取り、それに基づいて転送処理を行うようになる。
from datetime import datetime
from hashlib import sha256
import random
TOKEN_TYPES = {
1: "AIR（Root）",
2: "AIS（Sacral）",
3: "AIP（Solar Plexus）",
4: "AIH（Heart）",
5: "AIT（Throat）",
6: "AII（Third Eye）",
7: "AIC（Crown）",
8: "AIU（Universal）",
9: "AIE（Earth Star）",
10: "AIM（Solar Matrix）"
}
class Transaction:
def __init__(self, sender, receiver, location, love_action_level, action_content, sender_dimension, receiver_dimension):
self.transaction_id = sha256(str(random.getrandbits(256)).encode()).hexdigest()
self.sender = sender
self.receiver = receiver
self.timestamp = str(datetime.now())
self.location = location
self.love_action_level = love_action_level
self.action_content = action_content
self.approval_target = None
self.zero_knowledge_proof = None
self.sender_dimension = sender_dimension
self.receiver_dimension = receiver_dimension
def generate_proof_of_place(self):
return f"トランザクション {self.transaction_id} の位置情報のPoPが生成されました: {self.location}"
def generate_proof_of_history(self):
return f"トランザクション {self.transaction_id} の履歴のPoHが生成されました: {self.timestamp}"
def generate_zero_knowledge_proof(self):
n, g, lam = generate_key()
m = random.randint(1, n - 1)
c = encrypt(m, n, g)
proof = generate_zero_knowledge_proof(n, g, lam, m, c)
self.zero_knowledge_proof = proof
def transfer_token(self, love_currency, sender_dimension, receiver_dimension):
# ブロックチェーン側でトークンの転送を行う
print(f"Token transfer: {love_currency} token transferred from {self.sender} to {self.receiver} in dimension {receiver_dimension}.")
def decrypt_data(self, private_key):
decrypted_data = decrypt(self.encrypted_data, private_key)
return decrypted_data
class Block:
def __init__(self, index, previous_hash, timestamp, data, proof_of_place, proof_of_history, zero_knowledge_proof):
self.index = index
self.previous_hash = previous_hash
self.timestamp = timestamp
self.data = data
self.proof_of_place = proof_of_place
self.proof_of_history = proof_of_history
self.zero_knowledge_proof = zero_knowledge_proof
self.hash = self.calculate_hash()
def calculate_hash(self):
hash_data = (
str(self.index) +
str(self.previous_hash) +
str(self.timestamp) +
str(self.data) +
str(self.proof_of_place) +
str(self.proof_of_history) +
str(self.zero_knowledge_proof)
)
return sha256(hash_data.encode()).hexdigest()
class Blockchain:
def __init__(self):
self.chain = [self.create_genesis_block()]
def create_genesis_block(self):
return Block(0, "0", datetime.now(), "Genesis Block", "Proof of Place", "Proof of History", "Zero Knowledge Proof")
def get_latest_block(self):
return self.chain[-1]
def add_block(self, transaction):
index = len(self.chain)
previous_block = self.get_latest_block()
new_block = Block(index, previous_block.hash, datetime.now(), transaction, transaction.generate_proof_of_place(), transaction.generate_proof_of_history(), transaction.zero_knowledge_proof)
self.chain.append(new_block)
def generate_key():
p = 499
q = 547
n = p * q
lam = (p-1)*(q-1)
g = 2
return (n, g, lam)
def encrypt(m, n, g):
r = random.randint(1, n-1)
c = (pow(g, m, n**2) * pow(r, n, n**2)) % (n**2)
return c
def decrypt(c, private_key):
n, g, _ = private_key
phi_n = (n - 1) // 2
m = ((pow(c, phi_n, n**2) - 1) // n) * g % n
return m
blockchain = Blockchain()
users = {
"A": {"location": "Location1", "love_action_level": 8, "action_content": "Action Content A", "sender_dimension": 2, "receiver_dimension": 4},
"B": {"location": "Location2", "love_action_level": 6, "action_content": "Action Content B", "sender_dimension": 2, "receiver_dimension": 3},
"C": {"location": "Location3", "love_action_level": 3, "action_content": "Action Content C", "sender_dimension": 3, "receiver_dimension": 4},
"D": {"location": "Location4", "love_action_level": 10, "action_content": "Action Content D", "sender_dimension": 3, "receiver_dimension": 2}
}
for sender_name, sender_data in users.items():
for receiver_name, receiver_data in users.items():
if sender_name != receiver_name:
transaction = Transaction(sender_name, receiver_name, sender_data["location"], sender_data["love_action_level"], sender_data["action_content"], sender_data["sender_dimension"], receiver_data["receiver_dimension"])
transaction.transfer_token()
blockchain.add_block(transaction)
latest_block = blockchain.get_latest_block()
print(f"Latest Block #{latest_block.index} - Hash: {latest_block.hash}")
いかがであろうか、このようにして送信者と異なる次元で、受信者が愛貨を受け取ることができるようになる。このようにプログラムすることで、創造性も広がるし、愛の行動の質も変わってくる。社会がどのように変化するのか見てみたい。