df865c55b8
Fixed two CLI bugs exposed during training: 1. wallet send - Fixed 'name requests is not defined' - Added missing 'import requests' in cli/handlers/wallet.py - Command now reaches RPC correctly; failures are blockchain-level 2. wallet transactions - Fixed 'list object has no attribute get' - Updated get_transactions in cli/aitbc_cli.py to handle both list and dict responses - RPC /rpc/transactions returns a list, CLI expected dict with transactions key - Normalizes tx_hash to hash for display 3. Training self-transfer - Skip when wallet has 0 balance - Updated scripts/training/stage1_foundation.sh to check wallet balance before self-transfer - Avoids retrying guaranteed failures when wallet has no on-chain account Validation: - wallet transactions: No longer raises list.get error - wallet send: Fails correctly at blockchain layer (sender account not found) - Training script: Skips self-transfer when balance is 0
273 lines
10 KiB
Python
273 lines
10 KiB
Python
"""Wallet command handlers."""
|
|
|
|
import json
|
|
import requests
|
|
import sys
|
|
from aitbc.paths import get_data_path
|
|
|
|
|
|
def handle_wallet_create(args, create_wallet, read_password, first):
|
|
"""Handle wallet create command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
password = read_password(args, "wallet_password")
|
|
if not wallet_name or not password:
|
|
print("Error: Wallet name and password are required")
|
|
sys.exit(1)
|
|
address = create_wallet(wallet_name, password)
|
|
print(f"Wallet address: {address}")
|
|
|
|
|
|
def handle_wallet_list(args, list_wallets, output_format):
|
|
"""Handle wallet list command."""
|
|
wallets = list_wallets()
|
|
if output_format(args) == "json":
|
|
print(json.dumps(wallets, indent=2))
|
|
return
|
|
print("Wallets:")
|
|
for wallet in wallets:
|
|
print(f" {wallet['name']}: {wallet['address']}")
|
|
|
|
|
|
def handle_wallet_balance(args, default_rpc_url, list_wallets, get_balance, first):
|
|
"""Handle wallet balance command."""
|
|
rpc_url = getattr(args, "rpc_url", default_rpc_url)
|
|
if getattr(args, "all", False):
|
|
print("All wallet balances:")
|
|
for wallet in list_wallets():
|
|
balance_info = get_balance(wallet["name"], rpc_url=rpc_url)
|
|
if balance_info:
|
|
print(f" {wallet['name']}: {balance_info['balance']} AIT")
|
|
else:
|
|
print(f" {wallet['name']}: unavailable")
|
|
return
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
if not wallet_name:
|
|
print("Error: Wallet name is required")
|
|
sys.exit(1)
|
|
balance_info = get_balance(wallet_name, rpc_url=rpc_url)
|
|
if not balance_info:
|
|
sys.exit(1)
|
|
print(f"Wallet: {balance_info['wallet_name']}")
|
|
print(f"Address: {balance_info['address']}")
|
|
print(f"Balance: {balance_info['balance']} AIT")
|
|
print(f"Nonce: {balance_info['nonce']}")
|
|
|
|
|
|
def handle_wallet_transactions(args, get_transactions, output_format, first):
|
|
"""Handle wallet transactions command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
if not wallet_name:
|
|
print("Error: Wallet name is required")
|
|
sys.exit(1)
|
|
transactions = get_transactions(wallet_name, limit=args.limit, rpc_url=args.rpc_url)
|
|
if output_format(args) == "json":
|
|
print(json.dumps(transactions, indent=2))
|
|
return
|
|
print(f"Transactions for {wallet_name}:")
|
|
for index, tx in enumerate(transactions, 1):
|
|
print(f" {index}. Hash: {tx.get('hash', 'N/A')}")
|
|
print(f" Amount: {tx.get('value', 0)} AIT")
|
|
print(f" Fee: {tx.get('fee', 0)} AIT")
|
|
print(f" Type: {tx.get('type', 'N/A')}")
|
|
print()
|
|
|
|
|
|
def handle_wallet_send(args, send_transaction, read_password, first):
|
|
"""Handle wallet send command."""
|
|
from pathlib import Path
|
|
import json
|
|
from cryptography.hazmat.primitives.asymmetric import ed25519
|
|
|
|
from_wallet = first(getattr(args, "from_wallet_arg", None), getattr(args, "from_wallet", None))
|
|
to_address = first(getattr(args, "to_address_arg", None), getattr(args, "to_address", None))
|
|
amount_value = first(getattr(args, "amount_arg", None), getattr(args, "amount", None))
|
|
|
|
# Password is now required for signing
|
|
password = read_password(args, "wallet_password")
|
|
|
|
if not from_wallet or not to_address or amount_value is None:
|
|
print("Error: From wallet, destination, and amount are required")
|
|
sys.exit(1)
|
|
|
|
if not password:
|
|
print("Error: Password is required for signing transaction")
|
|
sys.exit(1)
|
|
|
|
# Use default fee if not specified
|
|
fee = getattr(args, "fee", 10)
|
|
if fee is None:
|
|
fee = 10
|
|
|
|
# Use direct RPC call with decrypted private key
|
|
keystore_dir = Path("/var/lib/aitbc/keystore")
|
|
sender_keystore = keystore_dir / f"{from_wallet}.json"
|
|
|
|
if not sender_keystore.exists():
|
|
print(f"Error: Wallet '{from_wallet}' not found")
|
|
sys.exit(1)
|
|
|
|
with open(sender_keystore) as f:
|
|
sender_data = json.load(f)
|
|
|
|
sender_address = sender_data['address']
|
|
|
|
# Decrypt private key for signing
|
|
try:
|
|
sys.path.insert(0, "/opt/aitbc/cli")
|
|
import importlib.util
|
|
spec = importlib.util.spec_from_file_location('aitbc_cli_module', '/opt/aitbc/cli/aitbc_cli.py')
|
|
aitbc_cli_module = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(aitbc_cli_module)
|
|
private_key_hex = aitbc_cli_module.decrypt_private_key(sender_keystore, password)
|
|
private_key = ed25519.Ed25519PrivateKey.from_private_bytes(bytes.fromhex(private_key_hex))
|
|
except Exception as e:
|
|
print(f"Error decrypting wallet: {e}")
|
|
sys.exit(1)
|
|
|
|
# Get RPC URL
|
|
rpc_url = getattr(args, "rpc_url", "http://localhost:8006")
|
|
|
|
# Get chain_id
|
|
try:
|
|
from sys.path import insert
|
|
insert(0, "/opt/aitbc")
|
|
from aitbc_cli.utils.chain_id import get_chain_id
|
|
chain_id = get_chain_id(rpc_url, override=None, timeout=5)
|
|
except Exception:
|
|
chain_id = "ait-testnet"
|
|
|
|
# Get actual nonce from blockchain
|
|
actual_nonce = 0
|
|
try:
|
|
account_data = requests.get(f"{rpc_url}/rpc/account/{sender_address}", timeout=5).json()
|
|
actual_nonce = account_data.get("nonce", 0)
|
|
except Exception:
|
|
actual_nonce = 0
|
|
|
|
# Build transaction with modern payload format
|
|
transaction_payload = {
|
|
"type": "TRANSFER",
|
|
"from": sender_address,
|
|
"to": to_address,
|
|
"amount": int(float(amount_value)),
|
|
"fee": fee,
|
|
"nonce": actual_nonce,
|
|
"payload": {
|
|
"recipient": to_address,
|
|
"amount": int(float(amount_value))
|
|
},
|
|
"chain_id": chain_id
|
|
}
|
|
|
|
# Sign transaction
|
|
message = json.dumps(transaction_payload, sort_keys=True).encode()
|
|
signature = private_key.sign(message)
|
|
signature_hex = signature.hex()
|
|
|
|
transaction_payload["signature"] = signature_hex
|
|
|
|
# Submit transaction
|
|
try:
|
|
response = requests.post(f"{rpc_url}/rpc/transaction", json=transaction_payload, timeout=30)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
if result.get("success"):
|
|
print("Transaction sent successfully")
|
|
print(f"Transaction hash: {result.get('transaction_hash')}")
|
|
else:
|
|
print(f"Transaction failed: {result.get('message', 'Unknown error')}")
|
|
sys.exit(1)
|
|
else:
|
|
print(f"Error submitting transaction: {response.status_code}")
|
|
print(f"Error: {response.text}")
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
print(f"Error submitting transaction: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_wallet_import(args, import_wallet, read_password, first):
|
|
"""Handle wallet import command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
private_key = first(getattr(args, "private_key_arg", None), getattr(args, "private_key_opt", None))
|
|
password = read_password(args, "wallet_password")
|
|
if not wallet_name or not private_key or not password:
|
|
print("Error: Wallet name, private key, and password are required")
|
|
sys.exit(1)
|
|
address = import_wallet(wallet_name, private_key, password)
|
|
if not address:
|
|
sys.exit(1)
|
|
print(f"Wallet address: {address}")
|
|
|
|
|
|
def handle_wallet_export(args, export_wallet, read_password, first):
|
|
"""Handle wallet export command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
password = read_password(args, "wallet_password")
|
|
if not wallet_name or not password:
|
|
print("Error: Wallet name and password are required")
|
|
sys.exit(1)
|
|
private_key = export_wallet(wallet_name, password)
|
|
if not private_key:
|
|
sys.exit(1)
|
|
print(private_key)
|
|
|
|
|
|
def handle_wallet_delete(args, delete_wallet, first):
|
|
"""Handle wallet delete command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
if not wallet_name or not args.confirm:
|
|
print("Error: Wallet name and --confirm are required")
|
|
sys.exit(1)
|
|
if not delete_wallet(wallet_name):
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_wallet_rename(args, rename_wallet, first):
|
|
"""Handle wallet rename command."""
|
|
old_name = first(getattr(args, "old_name_arg", None), getattr(args, "old_name", None))
|
|
new_name = first(getattr(args, "new_name_arg", None), getattr(args, "new_name", None))
|
|
if not old_name or not new_name:
|
|
print("Error: Old and new wallet names are required")
|
|
sys.exit(1)
|
|
if not rename_wallet(old_name, new_name):
|
|
sys.exit(1)
|
|
|
|
|
|
def handle_wallet_backup(args, first):
|
|
"""Handle wallet backup command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
if not wallet_name:
|
|
print("Error: Wallet name is required")
|
|
sys.exit(1)
|
|
print(f"Wallet backup: {wallet_name}")
|
|
backup_path = get_data_path("backups")
|
|
print(f" Backup created: {backup_path}/{wallet_name}_$(date +%Y%m%d).json")
|
|
print(" Status: completed")
|
|
|
|
|
|
def handle_wallet_sync(args, first):
|
|
"""Handle wallet sync command."""
|
|
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
|
|
if args.all:
|
|
print("Wallet sync: All wallets")
|
|
elif wallet_name:
|
|
print(f"Wallet sync: {wallet_name}")
|
|
else:
|
|
print("Error: Wallet name or --all is required")
|
|
sys.exit(1)
|
|
print(" Sync status: completed")
|
|
print(" Last sync: $(date)")
|
|
|
|
|
|
def handle_wallet_batch(args, send_batch_transactions, read_password):
|
|
"""Handle wallet batch command."""
|
|
password = read_password(args)
|
|
if not password:
|
|
print("Error: Password is required")
|
|
sys.exit(1)
|
|
with open(args.file) as handle:
|
|
transactions = json.load(handle)
|
|
send_batch_transactions(transactions, password, rpc_url=args.rpc_url)
|