Challenge Keys

const (
    EncodedKeyLength       = 147  // Modern key format (v3)
    EncodedKeyLengthLegacy = 136  // Legacy key format (v2 without salt)
)

const (
    KeySerializationVersion2 = 2  // Legacy format with birthday
    KeySerializationVersion3 = 3  // Modern format without birthday
)

func NewChallengePrivateKey(input, salt []byte) *ChallengePrivateKey

func (k *ChallengePrivateKey) SignSha(payload []byte) ([]byte, error)

func (k *ChallengePrivateKey) PubKey() *ChallengePublicKey

func (k *ChallengePrivateKey) PubKeyHex() string

func (k *ChallengePrivateKey) DecryptRawKey(encryptedKey string, network *Network) (*DecryptedPrivateKey, error)

func (k *ChallengePrivateKey) DecryptKey(decodedInfo *EncryptedPrivateKeyInfo, network *Network) (*DecryptedPrivateKey, error)

type DecryptedPrivateKey struct {
    Key      *HDPrivateKey  // The decrypted HD private key
    Birthday int            // Key birthday (block height, 0 for v3)
}

func NewChallengePublicKeyFromSerialized(serializedKey []byte) (*ChallengePublicKey, error)

func (k *ChallengePublicKey) EncryptKey(
    privKey *HDPrivateKey,
    recoveryCodeSalt []byte,
    birthday int,
    muunPrivateKey string,
) (string, error)

[1 byte: version=3]
[33 bytes: ephemeral public key]
[64 bytes: ciphertext (32-byte privKey + 32-byte chainCode)]
[8 bytes: recovery code salt]

[1 byte: version=2]
[2 bytes: birthday]
[33 bytes: ephemeral public key]
[64 bytes: ciphertext]
[8 bytes: recovery code salt]

func (k *ChallengePublicKey) GetChecksum() string

type EncryptedPrivateKeyInfo struct {
    Version      int     // Serialization version (2 or 3)
    Birthday     int     // Block height birthday (0 for v3)
    EphPublicKey string  // Hex-encoded ephemeral public key (33 bytes)
    CipherText   string  // Hex-encoded ciphertext (64 bytes)
    Salt         string  // Hex-encoded recovery code salt (8 bytes)
}

func DecodeEncryptedPrivateKey(encodedKey string) (*EncryptedPrivateKeyInfo, error)

package main

import (
    "fmt"
    "github.com/muun/libwallet"
)

func main() {
    network := libwallet.Mainnet()
    
    // User's recovery code and salt
    recoveryCode := []byte("user-recovery-code-words")
    salt := []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
    
    // Step 1: Derive challenge keys from recovery code
    challengePriv := libwallet.NewChallengePrivateKey(recoveryCode, salt)
    challengePub := challengePriv.PubKey()
    
    fmt.Printf("Challenge Public Key: %s\n", challengePriv.PubKeyHex())
    fmt.Printf("Checksum: %s\n", challengePub.GetChecksum())
    
    // Step 2: Create wallet key to encrypt
    walletSeed := []byte{/* 32-64 random bytes */}
    walletKey, _ := libwallet.NewHDPrivateKey(walletSeed, network)
    
    // Step 3: Encrypt wallet key with challenge public key
    birthday := 700000  // Block height
    muunKeyStr := "..." // Muun's encrypted key (determines version)
    
    encryptedKey, err := challengePub.EncryptKey(
        walletKey,
        salt,
        birthday,
        muunKeyStr,
    )
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Encrypted Key: %s\n", encryptedKey)
    
    // Step 4: Later, decrypt with recovery code
    decrypted, err := challengePriv.DecryptRawKey(encryptedKey, network)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Decrypted Key Path: %s\n", decrypted.Key.Path)
    fmt.Printf("Birthday: %d\n", decrypted.Birthday)
    
    // Step 5: Verify by comparing public keys
    originalPub := walletKey.PublicKey()
    decryptedPub := decrypted.Key.PublicKey()
    
    if originalPub.String() == decryptedPub.String() {
        fmt.Println("✓ Decryption successful!")
    }
}

// Recovery example
func recoverWallet(recoveryWords string, encryptedUserKey string, encryptedMuunKey string) error {
    network := libwallet.Mainnet()
    
    // Convert recovery words to bytes (implementation specific)
    recoveryCode := wordsToBytes(recoveryWords)
    
    // Decode to get salt
    keyInfo, _ := libwallet.DecodeEncryptedPrivateKey(encryptedUserKey)
    salt, _ := hex.DecodeString(keyInfo.Salt)
    
    // Derive challenge key
    challengeKey := libwallet.NewChallengePrivateKey(recoveryCode, salt)
    
    // Decrypt both keys
    userKey, err := challengeKey.DecryptRawKey(encryptedUserKey, network)
    if err != nil {
        return fmt.Errorf("failed to decrypt user key: %w", err)
    }
    
    muunKey, err := challengeKey.DecryptRawKey(encryptedMuunKey, network)
    if err != nil {
        return fmt.Errorf("failed to decrypt muun key: %w", err)
    }
    
    // Now have full wallet access with both keys
    fmt.Printf("User key: %s\n", userKey.Key.String())
    fmt.Printf("Muun key: %s\n", muunKey.Key.String())
    
    return nil
}