Verify Keypair

Learn how to verify that a private key corresponds to a specific public key address in Solana.

Code Example

#!/usr/bin/env python3
"""
Solana Cookbook - How to Verify a Keypair
"""

from solders.keypair import Keypair
from solders.pubkey import Pubkey

def main():
    public_key = Pubkey.from_string("24PNhTaNtomHhoy3fTRaMhAFCRj4uHqhZEEoWrKDbR5p")

    keypair_bytes = bytes([
        174, 47, 154, 16, 202, 193, 206, 113, 199, 190, 53, 133, 169, 175, 31, 56,
        222, 53, 138, 189, 224, 216, 117, 173, 10, 149, 53, 45, 73, 251, 237, 246, 15,
        185, 186, 82, 177, 240, 148, 69, 241, 227, 167, 80, 141, 89, 240, 121, 121,
        35, 172, 247, 68, 251, 226, 218, 48, 63, 176, 109, 168, 89, 238, 135
    ])

    signer = Keypair.from_bytes(keypair_bytes)

    print(signer.pubkey() == public_key)

if __name__ == "__main__":
    main()

Explanation

This example demonstrates how to verify that a private key matches a specific public key:

1. Define Expected Public Key: Create a Pubkey object from the expected address string
2. Restore Keypair: Reconstruct the keypair from the private key bytes
3. Compare Public Keys: Compare the derived public key with the expected one
4. Return Result: The comparison returns True if they match, False otherwise

Key Concepts

• Keypair Verification: Confirming that a private key generates a specific public key
• Public Key Derivation: Every private key deterministically produces one public key
• Address Validation: Ensuring private keys match expected wallet addresses
• Security Verification: Confirming key integrity before use

Usage

To run this example:

1. Install required dependencies:

   pip install solders
   

2. Run the script:

   python verify_keypair.py
   

The output will be True if the private key matches the public key, False otherwise.

Practical Applications

Wallet Verification

def verify_wallet_keypair(expected_address: str, private_key_bytes: bytes) -> bool:
    """Verify that a private key corresponds to an expected wallet address"""
    try:
        expected_pubkey = Pubkey.from_string(expected_address)
        keypair = Keypair.from_bytes(private_key_bytes)
        return keypair.pubkey() == expected_pubkey
    except Exception as e:
        print(f"Verification failed: {e}")
        return False

Backup Verification

def verify_backup_integrity(original_pubkey: Pubkey, backup_private_key: bytes) -> bool:
    """Verify that a backup private key can restore the original keypair"""
    try:
        restored_keypair = Keypair.from_bytes(backup_private_key)
        return restored_keypair.pubkey() == original_pubkey
    except Exception:
        return False

Multi-Key Verification

def verify_multiple_keypairs(key_pairs: list) -> dict:
    """Verify multiple keypair combinations"""
    results = {}

    for i, (address, private_key) in enumerate(key_pairs):
        try:
            expected_pubkey = Pubkey.from_string(address)
            keypair = Keypair.from_bytes(private_key)
            results[f"keypair_{i}"] = keypair.pubkey() == expected_pubkey
        except Exception as e:
            results[f"keypair_{i}"] = f"Error: {e}"

    return results

Security Use Cases

• Wallet Import: Verify imported private keys match expected addresses
• Backup Validation: Confirm backup files contain correct private keys
• Key Migration: Ensure keys are correctly transferred between systems
• Multi-signature Setup: Verify all participant keys are correct

Error Handling

def safe_verify_keypair(public_key_str: str, private_key_bytes: bytes) -> bool:
    """Safely verify keypair with proper error handling"""
    try:
        public_key = Pubkey.from_string(public_key_str)
        keypair = Keypair.from_bytes(private_key_bytes)
        return keypair.pubkey() == public_key
    except ValueError as e:
        print(f"Invalid public key format: {e}")
        return False
    except Exception as e:
        print(f"Keypair verification failed: {e}")
        return False

Best Practices

1. Always Verify: Verify keypairs before using them in transactions
2. Handle Errors: Use try-catch blocks for robust error handling
3. Validate Input: Ensure public key strings and private key bytes are valid
4. Log Results: Log verification results for debugging and auditing

Note: This example uses sample keys for demonstration. In production, use your actual private keys and expected addresses.