hippius 0.2.49__tar.gz → 0.2.51__tar.gz

{hippius-0.2.49 → hippius-0.2.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hippius
-Version: 0.2.49
+Version: 0.2.51
 Summary: Python SDK and CLI for Hippius blockchain storage
 Home-page: https://github.com/thenervelab/hippius-sdk
 Author: Dubs

{hippius-0.2.49 → hippius-0.2.51}/hippius_sdk/__init__.py

@@ -26,7 +26,7 @@ from hippius_sdk.config import (
 from hippius_sdk.ipfs import IPFSClient, S3PublishResult, S3DownloadResult
 from hippius_sdk.utils import format_cid, format_size, hex_to_ipfs_cid
 
-__version__ = "0.2.49"
+__version__ = "0.2.51"
 __all__ = [
     "HippiusClient",
     "IPFSClient",

{hippius-0.2.49 → hippius-0.2.51}/hippius_sdk/cli.py

@@ -418,15 +418,15 @@ def main():
                     args.node_id,
                     args.node_priv_hex,
                     args.node_type,
-                    ipfs_config=getattr(args, 'ipfs_config', None),
-                    ipfs_priv_b64=getattr(args, 'ipfs_priv_b64', None),
-                    ipfs_peer_id=getattr(args, 'ipfs_peer_id', None),
-                    pay_in_credits=getattr(args, 'pay_in_credits', False),
-                    expires_in=getattr(args, 'expires_in', 10),
-                    block_width=getattr(args, 'block_width', "u32"),
-                    domain=getattr(args, 'domain', "HIPPIUS::REGISTER::v1"),
-                    nonce_hex=getattr(args, 'nonce_hex', None),
-                    dry_run=getattr(args, 'dry_run', False),
+                    ipfs_config=getattr(args, "ipfs_config", None),
+                    ipfs_priv_b64=getattr(args, "ipfs_priv_b64", None),
+                    ipfs_peer_id=getattr(args, "ipfs_peer_id", None),
+                    pay_in_credits=getattr(args, "pay_in_credits", False),
+                    expires_in=getattr(args, "expires_in", 10),
+                    block_width=getattr(args, "block_width", "u32"),
+                    domain=getattr(args, "domain", "HIPPIUS::REGISTER::v1"),
+                    nonce_hex=getattr(args, "nonce_hex", None),
+                    dry_run=getattr(args, "dry_run", False),
                 )
             elif args.miner_action == "register-hotkey":
                 return run_async_handler(
@@ -436,15 +436,45 @@ def main():
                     args.node_id,
                     args.node_priv_hex,
                     args.node_type,
-                    ipfs_config=getattr(args, 'ipfs_config', None),
-                    ipfs_priv_b64=getattr(args, 'ipfs_priv_b64', None),
-                    ipfs_peer_id=getattr(args, 'ipfs_peer_id', None),
-                    pay_in_credits=getattr(args, 'pay_in_credits', False),
-                    expires_in=getattr(args, 'expires_in', 10),
-                    block_width=getattr(args, 'block_width', "u32"),
-                    domain=getattr(args, 'domain', "HIPPIUS::REGISTER::v1"),
-                    nonce_hex=getattr(args, 'nonce_hex', None),
-                    dry_run=getattr(args, 'dry_run', False),
+                    ipfs_config=getattr(args, "ipfs_config", None),
+                    ipfs_priv_b64=getattr(args, "ipfs_priv_b64", None),
+                    ipfs_peer_id=getattr(args, "ipfs_peer_id", None),
+                    pay_in_credits=getattr(args, "pay_in_credits", False),
+                    expires_in=getattr(args, "expires_in", 10),
+                    block_width=getattr(args, "block_width", "u32"),
+                    domain=getattr(args, "domain", "HIPPIUS::REGISTER::v1"),
+                    nonce_hex=getattr(args, "nonce_hex", None),
+                    dry_run=getattr(args, "dry_run", False),
+                )
+            elif args.miner_action == "verify-node":
+                return run_async_handler(
+                    cli_handlers.handle_verify_node,
+                    client,
+                    args.node_id,
+                    args.node_priv_hex,
+                    ipfs_config=getattr(args, "ipfs_config", None),
+                    ipfs_priv_b64=getattr(args, "ipfs_priv_b64", None),
+                    ipfs_peer_id=getattr(args, "ipfs_peer_id", None),
+                    expires_in=getattr(args, "expires_in", 10),
+                    block_width=getattr(args, "block_width", "u32"),
+                    domain=getattr(args, "domain", "HIPPIUS::REGISTER::v1"),
+                    nonce_hex=getattr(args, "nonce_hex", None),
+                    dry_run=getattr(args, "dry_run", False),
+                )
+            elif args.miner_action == "verify-coldkey-node":
+                return run_async_handler(
+                    cli_handlers.handle_verify_coldkey_node,
+                    client,
+                    args.node_id,
+                    args.node_priv_hex,
+                    ipfs_config=getattr(args, "ipfs_config", None),
+                    ipfs_priv_b64=getattr(args, "ipfs_priv_b64", None),
+                    ipfs_peer_id=getattr(args, "ipfs_peer_id", None),
+                    expires_in=getattr(args, "expires_in", 10),
+                    block_width=getattr(args, "block_width", "u32"),
+                    domain=getattr(args, "domain", "HIPPIUS::REGISTER::v1"),
+                    nonce_hex=getattr(args, "nonce_hex", None),
+                    dry_run=getattr(args, "dry_run", False),
                 )
             else:
                 # Display the Hippius logo banner with Rich formatting

{hippius-0.2.49 → hippius-0.2.51}/hippius_sdk/cli_handlers.py

@@ -3309,6 +3309,437 @@ def handle_register_coldkey(
     dry_run: bool = False,
 ) -> int:
     """Handle miner register-coldkey command"""
+    try:
+        # Get current account info
+        account = get_active_account()
+        if not account:
+            error(
+                "No active account. Please set up an account first with 'hippius account create' or 'hippius seed set'"
+            )
+            return 1
+
+        account_address = get_account_address(account)
+        if not account_address:
+            error(f"Could not get address for account '{account}'")
+            return 1
+
+        info(
+            f"Registering node with coldkey using account: [bold cyan]{account}[/bold cyan] ({account_address})"
+        )
+
+        # Import and use incentives.py functionality
+        from hippius_sdk.incentives import (
+            load_ipfs_seed,
+            load_main_seed,
+            encode_account_id,
+            verify_peer_id,
+            blake2_256,
+            manual_encode_challenge,
+            get_peer_id_from_public_key,
+            get_public_key_from_peer_id,
+        )
+        from substrateinterface import SubstrateInterface, Keypair
+        from nacl.signing import SigningKey
+        import base58
+        import secrets
+        from binascii import hexlify
+
+        # Initialize SubstrateInterface
+        substrate = SubstrateInterface(url=client.substrate_client.url)
+
+        # Get genesis hash and current block
+        genesis_hash_hex = substrate.get_block_hash(0)
+        genesis_hash = bytes.fromhex(genesis_hash_hex[2:])
+        current_block_number = substrate.get_block_number(None)
+
+        log(f"Current block number: {current_block_number}")
+
+        # Process node_id
+        if node_id.startswith("0x"):
+            node_id_bytes = bytes.fromhex(node_id[2:])
+        else:
+            node_id_bytes = base58.b58decode(node_id)
+
+        # Load IPFS and main seeds
+        ipfs_seed, peerid_from_config = load_ipfs_seed(ipfs_config, ipfs_priv_b64)
+        main_seed = load_main_seed(node_priv_hex)
+
+        # Create signing keys
+        main_sk = SigningKey(main_seed)
+        main_pk = bytes(main_sk.verify_key)
+        ipfs_sk = SigningKey(ipfs_seed)
+        ipfs_pk = bytes(ipfs_sk.verify_key)
+
+        # Handle IPFS peer ID
+        if ipfs_peer_id:
+            ipfs_peer_id_bytes = base58.b58decode(ipfs_peer_id)
+        elif peerid_from_config:
+            ipfs_peer_id_bytes = base58.b58decode(peerid_from_config)
+        else:
+            if node_type in ["StorageMiner", "Validator"]:
+                error(
+                    "IPFS PeerID is required for StorageMiner and Validator node types"
+                )
+                return 1
+            ipfs_peer_id_bytes = b""
+
+        # Verify keys match node IDs
+        if not verify_peer_id(main_pk, node_id_bytes, "Ed25519"):
+            error("Main public key does not match node ID")
+            return 1
+
+        if ipfs_peer_id_bytes and not verify_peer_id(
+            ipfs_pk, ipfs_peer_id_bytes, "Ed25519"
+        ):
+            error("IPFS public key does not match peer ID")
+            return 1
+
+        # Create challenge data
+        domain_bytes = domain.encode()
+        domain24 = b"HIPPIUS::REGISTER::v1" + b"\x00" * 3
+        node_id_hash = blake2_256(node_id_bytes)
+        ipfs_peer_id_hash = blake2_256(ipfs_peer_id_bytes)
+
+        nonce = (
+            bytes.fromhex(nonce_hex[2:])
+            if nonce_hex and nonce_hex.startswith("0x")
+            else bytes.fromhex(nonce_hex)
+            if nonce_hex
+            else secrets.token_bytes(32)
+        )
+
+        expires_at_block = current_block_number + expires_in
+        account_bytes = encode_account_id(account_address)
+
+        challenge_data = {
+            "domain": domain24,
+            "genesis_hash": genesis_hash,
+            "account": account_bytes,
+            "node_id_hash": node_id_hash,
+            "ipfs_peer_id_hash": ipfs_peer_id_hash,
+            "block_number": current_block_number,
+            "nonce": nonce,
+            "expires_at": expires_at_block,
+        }
+
+        challenge_bytes = manual_encode_challenge(challenge_data, block_width)
+
+        # Sign challenge
+        main_sig = main_sk.sign(challenge_bytes).signature
+        ipfs_sig = ipfs_sk.sign(challenge_bytes).signature
+
+        # Build call parameters
+        call_params = {
+            "node_type": node_type,
+            "node_id": node_id,
+            "node_id_hex": "0x" + hexlify(node_id_bytes).decode(),
+            "pay_in_credits": pay_in_credits,
+            "ipfs_node_id": ipfs_peer_id,
+            "owner": account_address,
+            "ipfs_peer_id": ipfs_peer_id,
+            "ipfs_id_hex": "0x" + hexlify(ipfs_peer_id_bytes).decode(),
+            "main_key_type": "Ed25519",
+            "main_public_key": "0x" + main_pk.hex(),
+            "main_sig": "0x" + main_sig.hex(),
+            "ipfs_key_type": "Ed25519",
+            "ipfs_public_key": "0x" + ipfs_pk.hex(),
+            "ipfs_sig": "0x" + ipfs_sig.hex(),
+            "challenge_bytes": "0x" + challenge_bytes.hex(),
+        }
+
+        if dry_run:
+            log("Dry run mode - printing payload without submitting")
+            payload = {
+                "genesis_hash_hex": "0x" + genesis_hash.hex(),
+                "current_block_number": current_block_number,
+                "challenge_bytes_hex": "0x" + challenge_bytes.hex(),
+                "call_module": "Registration",
+                "call_function": "register_node_with_coldkey",
+                "call_params": call_params,
+            }
+            console.print(json.dumps(payload, indent=2))
+            return 0
+
+        # Get keypair for signing
+        from hippius_sdk.config import get_seed_phrase
+
+        seed_phrase = get_seed_phrase()
+        if not seed_phrase:
+            error("No seed phrase available for signing transaction")
+            return 1
+
+        kp = Keypair.create_from_uri(seed_phrase)
+
+        # Submit transaction
+        log("Submitting registration transaction...")
+        log(f"Using module: [bold cyan]Registration[/bold cyan]")
+        call = substrate.compose_call(
+            call_module="Registration",
+            call_function="register_node_with_coldkey",
+            call_params=call_params,
+        )
+        extrinsic = substrate.create_signed_extrinsic(call=call, keypair=kp)
+        receipt = substrate.submit_extrinsic(extrinsic, wait_for_inclusion=True)
+
+        result = {
+            "extrinsic_hash": receipt.extrinsic_hash,
+            "is_success": receipt.is_success,
+            "error_message": receipt.error_message,
+            "triggered_events": [str(event) for event in receipt.triggered_events],
+        }
+
+        if receipt.is_success:
+            success(f"Node registered successfully with coldkey!")
+            success(f"Transaction hash: {receipt.extrinsic_hash}")
+        else:
+            error(f"Registration failed: {receipt.error_message}")
+
+        log("Full result:")
+        console.print(json.dumps(result, indent=2))
+
+        return 0 if receipt.is_success else 1
+
+    except Exception as e:
+        error(f"Error registering node with coldkey: {e}")
+        if hasattr(e, "__traceback__"):
+            import traceback
+
+            traceback.print_exc()
+        return 1
+
+
+def handle_register_hotkey(
+    client: HippiusClient,
+    coldkey: str,
+    node_id: str,
+    node_priv_hex: str,
+    node_type: str,
+    ipfs_config: str = None,
+    ipfs_priv_b64: str = None,
+    ipfs_peer_id: str = None,
+    pay_in_credits: bool = False,
+    expires_in: int = 10,
+    block_width: str = "u32",
+    domain: str = "HIPPIUS::REGISTER::v1",
+    nonce_hex: str = None,
+    dry_run: bool = False,
+) -> int:
+    """Handle miner register-hotkey command"""
+    try:
+        # Get current account info
+        account = get_active_account()
+        if not account:
+            error(
+                "No active account. Please set up an account first with 'hippius account create' or 'hippius seed set'"
+            )
+            return 1
+
+        account_address = get_account_address(account)
+        if not account_address:
+            error(f"Could not get address for account '{account}'")
+            return 1
+
+        info(
+            f"Registering node with hotkey using account: [bold cyan]{account}[/bold cyan] ({account_address})"
+        )
+        info(f"Coldkey: [bold yellow]{coldkey}[/bold yellow]")
+
+        # Import and use incentives.py functionality
+        from hippius_sdk.incentives import (
+            load_ipfs_seed,
+            load_main_seed,
+            encode_account_id,
+            verify_peer_id,
+            blake2_256,
+            manual_encode_challenge,
+            get_peer_id_from_public_key,
+            get_public_key_from_peer_id,
+        )
+        from substrateinterface import SubstrateInterface, Keypair
+        from nacl.signing import SigningKey
+        import base58
+        import secrets
+        from binascii import hexlify
+
+        # Initialize SubstrateInterface
+        substrate = SubstrateInterface(url=client.substrate_client.url)
+
+        # Get genesis hash and current block
+        genesis_hash_hex = substrate.get_block_hash(0)
+        genesis_hash = bytes.fromhex(genesis_hash_hex[2:])
+        current_block_number = substrate.get_block_number(None)
+
+        log(f"Current block number: {current_block_number}")
+
+        # Process node_id
+        if node_id.startswith("0x"):
+            node_id_bytes = bytes.fromhex(node_id[2:])
+        else:
+            node_id_bytes = base58.b58decode(node_id)
+
+        # Load IPFS and main seeds
+        ipfs_seed, peerid_from_config = load_ipfs_seed(ipfs_config, ipfs_priv_b64)
+        main_seed = load_main_seed(node_priv_hex)
+
+        # Create signing keys
+        main_sk = SigningKey(main_seed)
+        main_pk = bytes(main_sk.verify_key)
+        ipfs_sk = SigningKey(ipfs_seed)
+        ipfs_pk = bytes(ipfs_sk.verify_key)
+
+        # Handle IPFS peer ID
+        if ipfs_peer_id:
+            ipfs_peer_id_bytes = base58.b58decode(ipfs_peer_id)
+        elif peerid_from_config:
+            ipfs_peer_id_bytes = base58.b58decode(peerid_from_config)
+        else:
+            if node_type in ["StorageMiner", "Validator"]:
+                error(
+                    "IPFS PeerID is required for StorageMiner and Validator node types"
+                )
+                return 1
+            ipfs_peer_id_bytes = b""
+
+        # Verify keys match node IDs
+        if not verify_peer_id(main_pk, node_id_bytes, "Ed25519"):
+            error("Main public key does not match node ID")
+            return 1
+
+        if ipfs_peer_id_bytes and not verify_peer_id(
+            ipfs_pk, ipfs_peer_id_bytes, "Ed25519"
+        ):
+            error("IPFS public key does not match peer ID")
+            return 1
+
+        # Create challenge data
+        domain_bytes = domain.encode()
+        domain24 = b"HIPPIUS::REGISTER::v1" + b"\x00" * 3
+        node_id_hash = blake2_256(node_id_bytes)
+        ipfs_peer_id_hash = blake2_256(ipfs_peer_id_bytes)
+
+        nonce = (
+            bytes.fromhex(nonce_hex[2:])
+            if nonce_hex and nonce_hex.startswith("0x")
+            else bytes.fromhex(nonce_hex)
+            if nonce_hex
+            else secrets.token_bytes(32)
+        )
+
+        expires_at_block = current_block_number + expires_in
+        account_bytes = encode_account_id(account_address)
+
+        challenge_data = {
+            "domain": domain24,
+            "genesis_hash": genesis_hash,
+            "account": account_bytes,
+            "node_id_hash": node_id_hash,
+            "ipfs_peer_id_hash": ipfs_peer_id_hash,
+            "block_number": current_block_number,
+            "nonce": nonce,
+            "expires_at": expires_at_block,
+        }
+
+        challenge_bytes = manual_encode_challenge(challenge_data, block_width)
+
+        # Sign challenge
+        main_sig = main_sk.sign(challenge_bytes).signature
+        ipfs_sig = ipfs_sk.sign(challenge_bytes).signature
+
+        # Build call parameters
+        call_params = {
+            "coldkey": coldkey,
+            "node_type": node_type,
+            "node_id": node_id,
+            "node_id_hex": "0x" + hexlify(node_id_bytes).decode(),
+            "pay_in_credits": pay_in_credits,
+            "ipfs_node_id": ipfs_peer_id,
+            "ipfs_peer_id": ipfs_peer_id,
+            "ipfs_id_hex": "0x" + hexlify(ipfs_peer_id_bytes).decode(),
+            "owner": account_address,
+            "main_key_type": "Ed25519",
+            "main_public_key": "0x" + main_pk.hex(),
+            "main_sig": "0x" + main_sig.hex(),
+            "ipfs_key_type": "Ed25519",
+            "ipfs_public_key": "0x" + ipfs_pk.hex(),
+            "ipfs_sig": "0x" + ipfs_sig.hex(),
+            "challenge_bytes": "0x" + challenge_bytes.hex(),
+        }
+
+        if dry_run:
+            log("Dry run mode - printing payload without submitting")
+            payload = {
+                "genesis_hash_hex": "0x" + genesis_hash.hex(),
+                "current_block_number": current_block_number,
+                "challenge_bytes_hex": "0x" + challenge_bytes.hex(),
+                "call_module": "Registration",
+                "call_function": "register_node_with_hotkey",
+                "call_params": call_params,
+            }
+            console.print(json.dumps(payload, indent=2))
+            return 0
+
+        # Get keypair for signing
+        from hippius_sdk.config import get_seed_phrase
+
+        seed_phrase = get_seed_phrase()
+        if not seed_phrase:
+            error("No seed phrase available for signing transaction")
+            return 1
+
+        kp = Keypair.create_from_uri(seed_phrase)
+
+        # Submit transaction
+        log("Submitting registration transaction...")
+        log(f"Using module: [bold cyan]Registration[/bold cyan]")
+        call = substrate.compose_call(
+            call_module="Registration",
+            call_function="register_node_with_hotkey",
+            call_params=call_params,
+        )
+        extrinsic = substrate.create_signed_extrinsic(call=call, keypair=kp)
+        receipt = substrate.submit_extrinsic(extrinsic, wait_for_inclusion=True)
+
+        result = {
+            "extrinsic_hash": receipt.extrinsic_hash,
+            "is_success": receipt.is_success,
+            "error_message": receipt.error_message,
+            "triggered_events": [str(event) for event in receipt.triggered_events],
+        }
+
+        if receipt.is_success:
+            success(f"Node registered successfully with hotkey!")
+            success(f"Transaction hash: {receipt.extrinsic_hash}")
+        else:
+            error(f"Registration failed: {receipt.error_message}")
+
+        log("Full result:")
+        console.print(json.dumps(result, indent=2))
+
+        return 0 if receipt.is_success else 1
+
+    except Exception as e:
+        error(f"Error registering node with hotkey: {e}")
+        if hasattr(e, "__traceback__"):
+            import traceback
+
+            traceback.print_exc()
+        return 1
+
+
+def handle_verify_node(
+    client: HippiusClient,
+    node_id: str,
+    node_priv_hex: str,
+    ipfs_config: str = None,
+    ipfs_priv_b64: str = None,
+    ipfs_peer_id: str = None,
+    expires_in: int = 10,
+    block_width: str = "u32",
+    domain: str = "HIPPIUS::REGISTER::v1",
+    nonce_hex: str = None,
+    dry_run: bool = False,
+) -> int:
+    """Handle miner verify-node command"""
     try:
         # Get current account info
         account = get_active_account()
@@ -3321,13 +3752,12 @@ def handle_register_coldkey(
             error(f"Could not get address for account '{account}'")
             return 1
         
-        info(f"Registering node with coldkey using account: [bold cyan]{account}[/bold cyan] ({account_address})")
+        info(f"Verifying existing node using account: [bold cyan]{account}[/bold cyan] ({account_address})")
         
         # Import and use incentives.py functionality
         from hippius_sdk.incentives import (
             load_ipfs_seed, load_main_seed, encode_account_id, verify_peer_id,
-            blake2_256, manual_encode_challenge, get_peer_id_from_public_key,
-            get_public_key_from_peer_id
+            blake2_256, manual_encode_challenge
         )
         from substrateinterface import SubstrateInterface, Keypair
         from nacl.signing import SigningKey
@@ -3367,9 +3797,7 @@ def handle_register_coldkey(
         elif peerid_from_config:
             ipfs_peer_id_bytes = base58.b58decode(peerid_from_config)
         else:
-            if node_type in ["StorageMiner", "Validator"]:
-                error("IPFS PeerID is required for StorageMiner and Validator node types")
-                return 1
+            # For verification, IPFS peer ID might not be required for all node types
             ipfs_peer_id_bytes = b''
         
         # Verify keys match node IDs
@@ -3411,15 +3839,10 @@ def handle_register_coldkey(
         main_sig = main_sk.sign(challenge_bytes).signature
         ipfs_sig = ipfs_sk.sign(challenge_bytes).signature
         
-        # Build call parameters
+        # Build call parameters for verify_existing_node
         call_params = {
-            "node_type": node_type,
             "node_id": node_id,
             "node_id_hex": "0x"+hexlify(node_id_bytes).decode(),
-            "pay_in_credits": pay_in_credits,
-            "ipfs_node_id": ipfs_peer_id,
-            "owner": account_address,
-            "ipfs_peer_id": ipfs_peer_id,
             "ipfs_id_hex": "0x"+hexlify(ipfs_peer_id_bytes).decode(),
             "main_key_type": "Ed25519",
             "main_public_key": "0x"+main_pk.hex(),
@@ -3437,14 +3860,15 @@ def handle_register_coldkey(
                 "current_block_number": current_block_number,
                 "challenge_bytes_hex": "0x"+challenge_bytes.hex(),
                 "call_module": "Registration",
-                "call_function": "register_node_with_coldkey",
+                "call_function": "verify_existing_node",
                 "call_params": call_params
             }
             console.print(json.dumps(payload, indent=2))
             return 0
         
         # Get keypair for signing
-        seed_phrase = client.substrate_client._get_seed_phrase()
+        from hippius_sdk.config import get_seed_phrase
+        seed_phrase = get_seed_phrase()
         if not seed_phrase:
             error("No seed phrase available for signing transaction")
             return 1
@@ -3452,10 +3876,11 @@ def handle_register_coldkey(
         kp = Keypair.create_from_uri(seed_phrase)
         
         # Submit transaction
-        log("Submitting registration transaction...")
+        log("Submitting node verification transaction...")
+        log(f"Using module: [bold cyan]Registration[/bold cyan]")
         call = substrate.compose_call(
             call_module="Registration",
-            call_function="register_node_with_coldkey",
+            call_function="verify_existing_node",
             call_params=call_params
         )
         extrinsic = substrate.create_signed_extrinsic(call=call, keypair=kp)
@@ -3469,10 +3894,10 @@ def handle_register_coldkey(
         }
         
         if receipt.is_success:
-            success(f"Node registered successfully with coldkey!")
+            success(f"Node verification successful!")
             success(f"Transaction hash: {receipt.extrinsic_hash}")
         else:
-            error(f"Registration failed: {receipt.error_message}")
+            error(f"Node verification failed: {receipt.error_message}")
             
         log("Full result:")
         console.print(json.dumps(result, indent=2))
@@ -3480,30 +3905,27 @@ def handle_register_coldkey(
         return 0 if receipt.is_success else 1
         
     except Exception as e:
-        error(f"Error registering node with coldkey: {e}")
+        error(f"Error verifying node: {e}")
         if hasattr(e, '__traceback__'):
             import traceback
             traceback.print_exc()
         return 1
 
 
-def handle_register_hotkey(
+def handle_verify_coldkey_node(
     client: HippiusClient,
-    coldkey: str,
     node_id: str,
     node_priv_hex: str,
-    node_type: str,
     ipfs_config: str = None,
     ipfs_priv_b64: str = None,
     ipfs_peer_id: str = None,
-    pay_in_credits: bool = False,
     expires_in: int = 10,
     block_width: str = "u32",
     domain: str = "HIPPIUS::REGISTER::v1",
     nonce_hex: str = None,
     dry_run: bool = False,
 ) -> int:
-    """Handle miner register-hotkey command"""
+    """Handle miner verify-coldkey-node command"""
     try:
         # Get current account info
         account = get_active_account()
@@ -3516,14 +3938,12 @@ def handle_register_hotkey(
             error(f"Could not get address for account '{account}'")
             return 1
         
-        info(f"Registering node with hotkey using account: [bold cyan]{account}[/bold cyan] ({account_address})")
-        info(f"Coldkey: [bold yellow]{coldkey}[/bold yellow]")
+        info(f"Verifying existing coldkey node using account: [bold cyan]{account}[/bold cyan] ({account_address})")
         
         # Import and use incentives.py functionality
         from hippius_sdk.incentives import (
             load_ipfs_seed, load_main_seed, encode_account_id, verify_peer_id,
-            blake2_256, manual_encode_challenge, get_peer_id_from_public_key,
-            get_public_key_from_peer_id
+            blake2_256, manual_encode_challenge
         )
         from substrateinterface import SubstrateInterface, Keypair
         from nacl.signing import SigningKey
@@ -3563,9 +3983,7 @@ def handle_register_hotkey(
         elif peerid_from_config:
             ipfs_peer_id_bytes = base58.b58decode(peerid_from_config)
         else:
-            if node_type in ["StorageMiner", "Validator"]:
-                error("IPFS PeerID is required for StorageMiner and Validator node types")
-                return 1
+            # For verification, IPFS peer ID might not be required for all node types
             ipfs_peer_id_bytes = b''
         
         # Verify keys match node IDs
@@ -3607,17 +4025,11 @@ def handle_register_hotkey(
         main_sig = main_sk.sign(challenge_bytes).signature
         ipfs_sig = ipfs_sk.sign(challenge_bytes).signature
         
-        # Build call parameters
+        # Build call parameters for verify_existing_coldkey_node
         call_params = {
-            "coldkey": coldkey,
-            "node_type": node_type,
             "node_id": node_id,
             "node_id_hex": "0x"+hexlify(node_id_bytes).decode(),
-            "pay_in_credits": pay_in_credits,
-            "ipfs_node_id": ipfs_peer_id,
-            "ipfs_peer_id": ipfs_peer_id,
             "ipfs_id_hex": "0x"+hexlify(ipfs_peer_id_bytes).decode(),
-            "owner": account_address,
             "main_key_type": "Ed25519",
             "main_public_key": "0x"+main_pk.hex(),
             "main_sig": "0x"+main_sig.hex(),
@@ -3634,14 +4046,15 @@ def handle_register_hotkey(
                 "current_block_number": current_block_number,
                 "challenge_bytes_hex": "0x"+challenge_bytes.hex(),
                 "call_module": "Registration",
-                "call_function": "register_node_with_hotkey",
+                "call_function": "verify_existing_coldkey_node",
                 "call_params": call_params
             }
             console.print(json.dumps(payload, indent=2))
             return 0
         
         # Get keypair for signing
-        seed_phrase = client.substrate_client._get_seed_phrase()
+        from hippius_sdk.config import get_seed_phrase
+        seed_phrase = get_seed_phrase()
         if not seed_phrase:
             error("No seed phrase available for signing transaction")
             return 1
@@ -3649,10 +4062,11 @@ def handle_register_hotkey(
         kp = Keypair.create_from_uri(seed_phrase)
         
         # Submit transaction
-        log("Submitting registration transaction...")
+        log("Submitting coldkey node verification transaction...")
+        log(f"Using module: [bold cyan]Registration[/bold cyan]")
         call = substrate.compose_call(
             call_module="Registration",
-            call_function="register_node_with_hotkey",
+            call_function="verify_existing_coldkey_node",
             call_params=call_params
         )
         extrinsic = substrate.create_signed_extrinsic(call=call, keypair=kp)
@@ -3666,10 +4080,10 @@ def handle_register_hotkey(
         }
         
         if receipt.is_success:
-            success(f"Node registered successfully with hotkey!")
+            success(f"Coldkey node verification successful!")
             success(f"Transaction hash: {receipt.extrinsic_hash}")
         else:
-            error(f"Registration failed: {receipt.error_message}")
+            error(f"Coldkey node verification failed: {receipt.error_message}")
             
         log("Full result:")
         console.print(json.dumps(result, indent=2))
@@ -3677,7 +4091,7 @@ def handle_register_hotkey(
         return 0 if receipt.is_success else 1
         
     except Exception as e:
-        error(f"Error registering node with hotkey: {e}")
+        error(f"Error verifying coldkey node: {e}")
         if hasattr(e, '__traceback__'):
             import traceback
             traceback.print_exc()

{hippius-0.2.49 → hippius-0.2.51}/hippius_sdk/cli_parser.py

@@ -667,64 +667,75 @@ def add_miner_commands(subparsers):
 
     # Register coldkey command
     register_coldkey_parser = miner_subparsers.add_parser(
-        "register-coldkey", help="Register a node with coldkey (current account becomes coldkey)"
+        "register-coldkey",
+        help="Register a node with coldkey (current account becomes coldkey)",
     )
-    
+
     # Required arguments for register-coldkey
     register_coldkey_parser.add_argument(
         "--node-id", required=True, help="Your main node_id (libp2p peer ID)"
     )
     register_coldkey_parser.add_argument(
-        "--node-priv-hex", required=True, help="Main libp2p ed25519 private key hex (32/64B)"
+        "--node-priv-hex",
+        required=True,
+        help="Main libp2p ed25519 private key hex (32/64B)",
     )
     register_coldkey_parser.add_argument(
-        "--node-type", required=True,
+        "--node-type",
+        required=True,
         choices=["StorageMiner", "Validator", "ComputeMiner", "StorageS3", "GpuMiner"],
-        help="Type of miner node"
+        help="Type of miner node",
     )
-    
+
     # IPFS configuration (one required)
     ipfs_group = register_coldkey_parser.add_mutually_exclusive_group(required=True)
     ipfs_group.add_argument(
         "--ipfs-config", help="Path to IPFS config file (e.g. ~/.ipfs/config)"
     )
     ipfs_group.add_argument(
-        "--ipfs-priv-b64", help="IPFS Identity.PrivKey base64 if not using --ipfs-config"
+        "--ipfs-priv-b64",
+        help="IPFS Identity.PrivKey base64 if not using --ipfs-config",
     )
-    
+
     # Optional arguments
     register_coldkey_parser.add_argument(
         "--ipfs-peer-id", help="Optional override IPFS PeerID"
     )
     register_coldkey_parser.add_argument(
-        "--pay-in-credits", action="store_true", 
-        help="Pay in credits for registration"
+        "--pay-in-credits", action="store_true", help="Pay in credits for registration"
     )
     register_coldkey_parser.add_argument(
-        "--expires-in", type=int, default=10,
-        help="Challenge expiration in blocks (default: 10)"
+        "--expires-in",
+        type=int,
+        default=10,
+        help="Challenge expiration in blocks (default: 10)",
     )
     register_coldkey_parser.add_argument(
-        "--block-width", choices=["u32", "u64"], default="u32",
-        help="Block number width (default: u32)"
+        "--block-width",
+        choices=["u32", "u64"],
+        default="u32",
+        help="Block number width (default: u32)",
     )
     register_coldkey_parser.add_argument(
-        "--domain", default="HIPPIUS::REGISTER::v1",
-        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)"
+        "--domain",
+        default="HIPPIUS::REGISTER::v1",
+        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)",
     )
     register_coldkey_parser.add_argument(
         "--nonce-hex", help="32-byte hex nonce (optional, random if not provided)"
     )
     register_coldkey_parser.add_argument(
-        "--dry-run", action="store_true",
-        help="Do not submit extrinsic; just print payload"
+        "--dry-run",
+        action="store_true",
+        help="Do not submit extrinsic; just print payload",
     )
 
     # Register hotkey command
     register_hotkey_parser = miner_subparsers.add_parser(
-        "register-hotkey", help="Register a node with hotkey (current account becomes hotkey)"
+        "register-hotkey",
+        help="Register a node with hotkey (current account becomes hotkey)",
     )
-    
+
     # Required arguments for register-hotkey
     register_hotkey_parser.add_argument(
         "--coldkey", required=True, help="Coldkey SS58 address"
@@ -733,49 +744,183 @@ def add_miner_commands(subparsers):
         "--node-id", required=True, help="Your main node_id (libp2p peer ID)"
     )
     register_hotkey_parser.add_argument(
-        "--node-priv-hex", required=True, help="Main libp2p ed25519 private key hex (32/64B)"
+        "--node-priv-hex",
+        required=True,
+        help="Main libp2p ed25519 private key hex (32/64B)",
     )
     register_hotkey_parser.add_argument(
-        "--node-type", required=True,
+        "--node-type",
+        required=True,
         choices=["StorageMiner", "Validator", "ComputeMiner", "StorageS3", "GpuMiner"],
-        help="Type of miner node"
+        help="Type of miner node",
     )
-    
+
     # IPFS configuration (one required)
-    ipfs_group_hotkey = register_hotkey_parser.add_mutually_exclusive_group(required=True)
+    ipfs_group_hotkey = register_hotkey_parser.add_mutually_exclusive_group(
+        required=True
+    )
     ipfs_group_hotkey.add_argument(
         "--ipfs-config", help="Path to IPFS config file (e.g. ~/.ipfs/config)"
     )
     ipfs_group_hotkey.add_argument(
-        "--ipfs-priv-b64", help="IPFS Identity.PrivKey base64 if not using --ipfs-config"
+        "--ipfs-priv-b64",
+        help="IPFS Identity.PrivKey base64 if not using --ipfs-config",
     )
-    
+
     # Optional arguments
     register_hotkey_parser.add_argument(
         "--ipfs-peer-id", help="Optional override IPFS PeerID"
     )
     register_hotkey_parser.add_argument(
-        "--pay-in-credits", action="store_true",
-        help="Pay in credits for registration"
+        "--pay-in-credits", action="store_true", help="Pay in credits for registration"
     )
     register_hotkey_parser.add_argument(
-        "--expires-in", type=int, default=10,
-        help="Challenge expiration in blocks (default: 10)"
+        "--expires-in",
+        type=int,
+        default=10,
+        help="Challenge expiration in blocks (default: 10)",
     )
     register_hotkey_parser.add_argument(
-        "--block-width", choices=["u32", "u64"], default="u32",
-        help="Block number width (default: u32)"
+        "--block-width",
+        choices=["u32", "u64"],
+        default="u32",
+        help="Block number width (default: u32)",
     )
     register_hotkey_parser.add_argument(
-        "--domain", default="HIPPIUS::REGISTER::v1",
-        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)"
+        "--domain",
+        default="HIPPIUS::REGISTER::v1",
+        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)",
     )
     register_hotkey_parser.add_argument(
         "--nonce-hex", help="32-byte hex nonce (optional, random if not provided)"
     )
     register_hotkey_parser.add_argument(
-        "--dry-run", action="store_true",
-        help="Do not submit extrinsic; just print payload"
+        "--dry-run",
+        action="store_true",
+        help="Do not submit extrinsic; just print payload",
+    )
+
+    # Verify node command
+    verify_node_parser = miner_subparsers.add_parser(
+        "verify-node", help="Verify an existing registered node (proves key ownership)"
+    )
+
+    # Required arguments for verify-node
+    verify_node_parser.add_argument(
+        "--node-id", required=True, help="Your main node_id (libp2p peer ID)"
+    )
+    verify_node_parser.add_argument(
+        "--node-priv-hex",
+        required=True,
+        help="Main libp2p ed25519 private key hex (32/64B)",
+    )
+
+    # IPFS configuration (one required)
+    ipfs_group_verify = verify_node_parser.add_mutually_exclusive_group(required=True)
+    ipfs_group_verify.add_argument(
+        "--ipfs-config", help="Path to IPFS config file (e.g. ~/.ipfs/config)"
+    )
+    ipfs_group_verify.add_argument(
+        "--ipfs-priv-b64",
+        help="IPFS Identity.PrivKey base64 if not using --ipfs-config",
+    )
+
+    # Optional arguments
+    verify_node_parser.add_argument(
+        "--ipfs-peer-id", help="Optional override IPFS PeerID"
+    )
+    verify_node_parser.add_argument(
+        "--expires-in",
+        type=int,
+        default=10,
+        help="Challenge expiration in blocks (default: 10)",
+    )
+    verify_node_parser.add_argument(
+        "--block-width",
+        choices=["u32", "u64"],
+        default="u32",
+        help="Block number width (default: u32)",
+    )
+    verify_node_parser.add_argument(
+        "--domain",
+        default="HIPPIUS::REGISTER::v1",
+        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)",
+    )
+    verify_node_parser.add_argument(
+        "--nonce-hex", help="32-byte hex nonce (optional, random if not provided)"
+    )
+    verify_node_parser.add_argument(
+        "--module",
+        default="Registration",
+        help="Blockchain pallet/module name (default: Registration)",
+    )
+    verify_node_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Do not submit extrinsic; just print payload",
+    )
+
+    # Verify coldkey node command
+    verify_coldkey_node_parser = miner_subparsers.add_parser(
+        "verify-coldkey-node",
+        help="Verify an existing coldkey-registered node (proves key ownership)",
+    )
+
+    # Required arguments for verify-coldkey-node
+    verify_coldkey_node_parser.add_argument(
+        "--node-id", required=True, help="Your main node_id (libp2p peer ID)"
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--node-priv-hex",
+        required=True,
+        help="Main libp2p ed25519 private key hex (32/64B)",
+    )
+
+    # IPFS configuration (one required)
+    ipfs_group_verify_coldkey = verify_coldkey_node_parser.add_mutually_exclusive_group(
+        required=True
+    )
+    ipfs_group_verify_coldkey.add_argument(
+        "--ipfs-config", help="Path to IPFS config file (e.g. ~/.ipfs/config)"
+    )
+    ipfs_group_verify_coldkey.add_argument(
+        "--ipfs-priv-b64",
+        help="IPFS Identity.PrivKey base64 if not using --ipfs-config",
+    )
+
+    # Optional arguments
+    verify_coldkey_node_parser.add_argument(
+        "--ipfs-peer-id", help="Optional override IPFS PeerID"
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--expires-in",
+        type=int,
+        default=10,
+        help="Challenge expiration in blocks (default: 10)",
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--block-width",
+        choices=["u32", "u64"],
+        default="u32",
+        help="Block number width (default: u32)",
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--domain",
+        default="HIPPIUS::REGISTER::v1",
+        help="Domain for challenge (default: HIPPIUS::REGISTER::v1)",
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--nonce-hex", help="32-byte hex nonce (optional, random if not provided)"
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--module",
+        default="Registration",
+        help="Blockchain pallet/module name (default: Registration)",
+    )
+    verify_coldkey_node_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Do not submit extrinsic; just print payload",
     )
 
 

{hippius-0.2.49 → hippius-0.2.51}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hippius"
-version = "0.2.49"
+version = "0.2.51"
 description = "Python SDK and CLI for Hippius blockchain storage"
 authors = ["Dubs <dubs@dubs.rs>"]
 readme = "README.md"