e60cc3226c
Some checks failed
API Endpoint Tests / test-api-endpoints (push) Successful in 9s
Blockchain Synchronization Verification / sync-verification (push) Failing after 1s
CLI Tests / test-cli (push) Failing after 3s
Documentation Validation / validate-docs (push) Successful in 6s
Documentation Validation / validate-policies-strict (push) Successful in 2s
Integration Tests / test-service-integration (push) Successful in 40s
Multi-Node Blockchain Health Monitoring / health-check (push) Successful in 1s
P2P Network Verification / p2p-verification (push) Successful in 2s
Production Tests / Production Integration Tests (push) Successful in 21s
Python Tests / test-python (push) Successful in 13s
Security Scanning / security-scan (push) Failing after 46s
Smart Contract Tests / test-solidity (map[name:aitbc-token path:packages/solidity/aitbc-token]) (push) Successful in 17s
Smart Contract Tests / lint-solidity (push) Successful in 10s
- Add sys import to 29 test files across agent-coordinator, blockchain-event-bridge, blockchain-node, and coordinator-api - Remove apps/blockchain-event-bridge/tests/test_integration.py (obsolete bridge integration tests) - Remove apps/coordinator-api/tests/test_integration.py (obsolete API integration tests) - Implement GPU registration in marketplace_gpu.py with GPURegistry model persistence
350 lines
12 KiB
Python
350 lines
12 KiB
Python
"""Messaging contract handlers."""
|
|
|
|
import json
|
|
import sys
|
|
|
|
import requests
|
|
|
|
|
|
def handle_messaging_deploy(args, default_rpc_url, render_mapping):
|
|
"""Handle messaging contract deployment."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
print(f"Deploying messaging contract to {rpc_url}...")
|
|
try:
|
|
params = {}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.post(f"{rpc_url}/rpc/contracts/deploy/messaging", json={}, params=params, timeout=30)
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
print("Messaging contract deployed successfully")
|
|
render_mapping("Deployment result:", result)
|
|
else:
|
|
print(f"Deployment failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error deploying messaging contract: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_state(args, default_rpc_url, output_format, render_mapping):
|
|
"""Handle messaging contract state query."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
print(f"Getting messaging contract state from {rpc_url}...")
|
|
try:
|
|
params = {}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.get(f"{rpc_url}/rpc/contracts/messaging/state", params=params, timeout=10)
|
|
if response.status_code == 200:
|
|
state = response.json()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(state, indent=2))
|
|
else:
|
|
render_mapping("Messaging contract state:", state)
|
|
else:
|
|
print(f"Query failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error getting contract state: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_topics(args, default_rpc_url, output_format, render_mapping):
|
|
"""Handle forum topics query."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
print(f"Getting forum topics from {rpc_url}...")
|
|
try:
|
|
params = {}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.get(f"{rpc_url}/rpc/messaging/topics", params=params, timeout=10)
|
|
if response.status_code == 200:
|
|
topics = response.json()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(topics, indent=2))
|
|
else:
|
|
print("Forum topics:")
|
|
if isinstance(topics, list):
|
|
for topic in topics:
|
|
print(f" ID: {topic.get('topic_id', 'N/A')}, Title: {topic.get('title', 'N/A')}")
|
|
else:
|
|
render_mapping("Topics:", topics)
|
|
else:
|
|
print(f"Query failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error getting topics: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_create_topic(args, default_rpc_url, read_password, render_mapping):
|
|
"""Handle forum topic creation."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.title or not args.content:
|
|
print("Error: --title and --content are required")
|
|
sys.exit(1)
|
|
|
|
# Get auth headers if wallet provided
|
|
headers = {}
|
|
if args.wallet:
|
|
password = read_password(args)
|
|
from keystore_auth import get_auth_headers
|
|
headers = get_auth_headers(args.wallet, password, args.password_file)
|
|
|
|
topic_data = {
|
|
"title": args.title,
|
|
"content": args.content,
|
|
}
|
|
if chain_id:
|
|
topic_data["chain_id"] = chain_id
|
|
|
|
print(f"Creating forum topic on {rpc_url}...")
|
|
try:
|
|
response = requests.post(f"{rpc_url}/rpc/messaging/topics/create", json=topic_data, headers=headers, timeout=30)
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
print("Topic created successfully")
|
|
render_mapping("Topic:", result)
|
|
else:
|
|
print(f"Creation failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error creating topic: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_messages(args, default_rpc_url, output_format, render_mapping):
|
|
"""Handle messages query for a topic."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.topic_id:
|
|
print("Error: --topic-id is required")
|
|
sys.exit(1)
|
|
|
|
print(f"Getting messages for topic {args.topic_id} from {rpc_url}...")
|
|
try:
|
|
params = {"topic_id": args.topic_id}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.get(f"{rpc_url}/rpc/messaging/topics/{args.topic_id}/messages", params=params, timeout=10)
|
|
if response.status_code == 200:
|
|
messages = response.json()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(messages, indent=2))
|
|
else:
|
|
print(f"Messages for topic {args.topic_id}:")
|
|
if isinstance(messages, list):
|
|
for msg in messages:
|
|
print(f" Message ID: {msg.get('message_id', 'N/A')}, Author: {msg.get('author', 'N/A')}")
|
|
else:
|
|
render_mapping("Messages:", messages)
|
|
else:
|
|
print(f"Query failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error getting messages: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_post(args, default_rpc_url, read_password, render_mapping):
|
|
"""Handle message posting to a topic."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.topic_id or not args.content:
|
|
print("Error: --topic-id and --content are required")
|
|
sys.exit(1)
|
|
|
|
# Get auth headers if wallet provided
|
|
headers = {}
|
|
if args.wallet:
|
|
password = read_password(args)
|
|
from keystore_auth import get_auth_headers
|
|
headers = get_auth_headers(args.wallet, password, args.password_file)
|
|
|
|
message_data = {
|
|
"topic_id": args.topic_id,
|
|
"content": args.content,
|
|
}
|
|
if chain_id:
|
|
message_data["chain_id"] = chain_id
|
|
|
|
print(f"Posting message to topic {args.topic_id} on {rpc_url}...")
|
|
try:
|
|
response = requests.post(f"{rpc_url}/rpc/messaging/messages/post", json=message_data, headers=headers, timeout=30)
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
print("Message posted successfully")
|
|
render_mapping("Message:", result)
|
|
else:
|
|
print(f"Post failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error posting message: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_vote(args, default_rpc_url, read_password, render_mapping):
|
|
"""Handle voting on a message."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.message_id or not args.vote:
|
|
print("Error: --message-id and --vote are required")
|
|
sys.exit(1)
|
|
|
|
# Get auth headers if wallet provided
|
|
headers = {}
|
|
if args.wallet:
|
|
password = read_password(args)
|
|
from keystore_auth import get_auth_headers
|
|
headers = get_auth_headers(args.wallet, password, args.password_file)
|
|
|
|
vote_data = {
|
|
"message_id": args.message_id,
|
|
"vote": args.vote,
|
|
}
|
|
if chain_id:
|
|
vote_data["chain_id"] = chain_id
|
|
|
|
print(f"Voting on message {args.message_id} on {rpc_url}...")
|
|
try:
|
|
response = requests.post(f"{rpc_url}/rpc/messaging/messages/{args.message_id}/vote", json=vote_data, headers=headers, timeout=30)
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
print("Vote recorded successfully")
|
|
render_mapping("Vote result:", result)
|
|
else:
|
|
print(f"Vote failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error voting on message: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_search(args, default_rpc_url, output_format, render_mapping):
|
|
"""Handle message search."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.query:
|
|
print("Error: --query is required")
|
|
sys.exit(1)
|
|
|
|
print(f"Searching messages for '{args.query}' on {rpc_url}...")
|
|
try:
|
|
params = {"query": args.query}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.get(f"{rpc_url}/rpc/messaging/messages/search", params=params, timeout=30)
|
|
if response.status_code == 200:
|
|
results = response.json()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(results, indent=2))
|
|
else:
|
|
print(f"Search results for '{args.query}':")
|
|
if isinstance(results, list):
|
|
for msg in results:
|
|
print(f" Message ID: {msg.get('message_id', 'N/A')}, Topic: {msg.get('topic_id', 'N/A')}")
|
|
else:
|
|
render_mapping("Search results:", results)
|
|
else:
|
|
print(f"Search failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error searching messages: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_reputation(args, default_rpc_url, output_format, render_mapping):
|
|
"""Handle agent reputation query."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.agent_id:
|
|
print("Error: --agent-id is required")
|
|
sys.exit(1)
|
|
|
|
print(f"Getting reputation for agent {args.agent_id} from {rpc_url}...")
|
|
try:
|
|
params = {}
|
|
if chain_id:
|
|
params["chain_id"] = chain_id
|
|
|
|
response = requests.get(f"{rpc_url}/rpc/messaging/agents/{args.agent_id}/reputation", params=params, timeout=10)
|
|
if response.status_code == 200:
|
|
reputation = response.json()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(reputation, indent=2))
|
|
else:
|
|
render_mapping(f"Agent {args.agent_id} reputation:", reputation)
|
|
else:
|
|
print(f"Query failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error getting reputation: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_messaging_moderate(args, default_rpc_url, read_password, render_mapping):
|
|
"""Handle message moderation."""
|
|
rpc_url = args.rpc_url or default_rpc_url
|
|
chain_id = getattr(args, "chain_id", None)
|
|
|
|
if not args.message_id or not args.action:
|
|
print("Error: --message-id and --action are required")
|
|
sys.exit(1)
|
|
|
|
# Get auth headers if wallet provided
|
|
headers = {}
|
|
if args.wallet:
|
|
password = read_password(args)
|
|
from keystore_auth import get_auth_headers
|
|
headers = get_auth_headers(args.wallet, password, args.password_file)
|
|
|
|
moderation_data = {
|
|
"message_id": args.message_id,
|
|
"action": args.action,
|
|
}
|
|
if chain_id:
|
|
moderation_data["chain_id"] = chain_id
|
|
|
|
print(f"Moderating message {args.message_id} on {rpc_url}...")
|
|
try:
|
|
response = requests.post(f"{rpc_url}/rpc/messaging/messages/{args.message_id}/moderate", json=moderation_data, headers=headers, timeout=30)
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
print("Moderation action completed successfully")
|
|
render_mapping("Moderation result:", result)
|
|
else:
|
|
print(f"Moderation failed: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error moderating message: {e}")
|
|
sys.exit(1)
|