Restore Keypair

Learn how to restore a Solana keypair from existing private key bytes for wallet recovery operations.

Code Example

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

from solders.keypair import Keypair

def main():
    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())

if __name__ == "__main__":
    main()

Explanation

This example demonstrates how to restore a keypair from existing private key bytes:

Define Private Key: Create a bytes array containing the 64-byte private key
Restore Keypair: Use Keypair.from_bytes() to reconstruct the keypair
Access Public Key: The restored keypair provides access to the public key
Verify Restoration: Print the public key to verify successful restoration

Key Concepts

Keypair Restoration: Rebuilding a keypair from stored private key bytes
Private Key Format: Solana private keys are 64 bytes (32 bytes seed + 32 bytes public key)
Deterministic Recovery: Same private key bytes always produce the same keypair
Wallet Recovery: Essential for restoring access to existing accounts

Usage

To run this example:

Install required dependencies:
```
pip install solders
```
Run the script:
```
python restore_keypair.py
```

The output will show the public key address corresponding to the restored keypair.

Common Use Cases

From File Storage

# Read private key from file
with open('private_key.txt', 'rb') as f:
    private_key_bytes = f.read()

keypair = Keypair.from_bytes(private_key_bytes)

From Base58 String

import base58

# Convert from base58 string format
private_key_string = "your_base58_private_key_here"
private_key_bytes = base58.b58decode(private_key_string)
keypair = Keypair.from_bytes(private_key_bytes)

From Environment Variable

import os
import base58

# Load from environment variable
private_key_env = os.getenv('SOLANA_PRIVATE_KEY')
if private_key_env:
    private_key_bytes = base58.b58decode(private_key_env)
    keypair = Keypair.from_bytes(private_key_bytes)

Security Considerations

Secure Storage: Never store private keys in plain text
Environment Variables: Use secure environment variables for production
File Permissions: Ensure private key files have restricted permissions
Backup Verification: Always verify restored keypairs match expected addresses

Error Handling

try:
    keypair = Keypair.from_bytes(keypair_bytes)
    print(f"Successfully restored keypair: {keypair.pubkey()}")
except Exception as e:
    print(f"Failed to restore keypair: {e}")

Note: The example shows a sample private key for demonstration. Never use this key for actual transactions as it's publicly visible.