walletpress/backend/wallet_engine/chain_addresses.py

"""Per-chain address encoders — the single source of truth for chain-specific formats.

This module replaces the broken `generator.py:_generate_*` dispatch logic for
chains that have non-trivial encoding (Cosmos, Stellar, Tezos, TON, etc.).

Every function takes raw cryptographic output (public key bytes) and returns
the address string. No BIP derivation happens here — that's `generator.py`.

Each encoder is verified against the official SDK with golden vectors in
`tests/test_address_vectors.py`. See ADDRESS_GENERATION.md for the per-chain
truth table.

Reference mnemonics and expected addresses are computed using:
  - bech32 (pip install bech32) for Cosmos family
  - stellar-sdk for Stellar
  - xrpl-py for XRP (well, the addresscodec module)
  - py-algorand-sdk for Algorand
  - tonsdk for TON (note: TON uses its own wordlist, not BIP39)
  - bitcash for BCH cashaddr
  - monero for Monero
  - substrate-interface for Substrate sr25519
"""

from __future__ import annotations

import base64
import hashlib
from typing import Final


# ═══════════════════════════════════════════════════════════════════════════════
# Low-level helpers
# ═══════════════════════════════════════════════════════════════════════════════


def ripemd160_of_sha256(data: bytes) -> bytes:
    """sha256(data) then ripemd160. The canonical 'hash160' for BTC-style chains."""
    return hashlib.new("ripemd160", hashlib.sha256(data).digest()).digest()


def crc16_xmodem(data: bytes) -> int:
    """CRC-16/XMODEM (poly 0x1021, init 0). Used by Stellar StrKey."""
    crc = 0
    for b in data:
        crc ^= b << 8
        for _ in range(8):
            crc = ((crc << 1) ^ 0x1021) if (crc & 0x8000) else (crc << 1)
            crc &= 0xFFFF
    return crc


def crc16_ccitt(data: bytes) -> int:
    """CRC-16/CCITT-FALSE (poly 0x1021, init 0). Used by TON address format."""
    return crc16_xmodem(data)  # identical algorithm


def base58_encode_check(payload: bytes, alphabet: bytes) -> str:
    """Base58Check-style encode with given alphabet. No version byte handling."""
    n = int.from_bytes(payload, "big")
    out = bytearray()
    while n:
        n, r = divmod(n, 58)
        out.insert(0, alphabet[r])
    pad = sum(1 for b in payload if b == 0)
    return (alphabet[0:1] * pad + bytes(out)).decode()


# ═══════════════════════════════════════════════════════════════════════════════
# Cosmos family — secp256k1 → bech32 with chain-specific HRP
# ═══════════════════════════════════════════════════════════════════════════════


def cosmos_address(compressed_pubkey: bytes, hrp: str) -> str:
    """Encode a secp256k1 compressed public key as a Cosmos-family address.

    Args:
        compressed_pubkey: 33-byte secp256k1 compressed pubkey.
        hrp: Human-readable prefix, e.g. "cosmos", "osmo", "inj", "evmos".

    Returns:
        Bech32-encoded address, e.g. "cosmos1...".

    Reference: https://github.com/cosmos/amino/blob/master/spec.md#public-keys
    and BIP-173 (bech32).
    """
    import bech32  # imported lazily so non-Cosmos chains don't need it
    sha = hashlib.sha256(compressed_pubkey).digest()
    ripe = hashlib.new("ripemd160", sha).digest()
    five_bit = bech32.convertbits(ripe, 8, 5)
    return bech32.bech32_encode(hrp, five_bit)


# ═══════════════════════════════════════════════════════════════════════════════
# Stellar — ed25519 → base32 + CRC16-XMODEM checksum
# ═══════════════════════════════════════════════════════════════════════════════


def stellar_address(ed25519_pubkey: bytes) -> str:
    """Encode an ed25519 public key as a Stellar classic address (G...).

    Format: 0x30 (ed25519 account version) || pubkey (32 bytes) || crc16 (2 bytes)
    Encoding: RFC 4648 base32 (no padding).

    Reference: https://github.com/StellarCN/py-stellar-base/blob/master/stellar_sdk/strkey.py
    """
    if len(ed25519_pubkey) != 32:
        raise ValueError(f"ed25519 pubkey must be 32 bytes, got {len(ed25519_pubkey)}")
    version = b"\x30"  # ed25519 account
    payload = version + ed25519_pubkey
    chk = crc16_xmodem(payload).to_bytes(2, "big")
    return base64.b32encode(payload + chk).decode().rstrip("=")


# ═══════════════════════════════════════════════════════════════════════════════
# XRP — secp256k1 → custom base58 alphabet (rpshnaf...)
# ═══════════════════════════════════════════════════════════════════════════════


# XRP uses a different base58 alphabet than Bitcoin. From rippled source.
XRP_ALPHABET: Final[bytes] = b"rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"


def xrp_address(compressed_pubkey: bytes) -> str:
    """Encode a secp256k1 compressed public key as an XRP classic address (r...).

    Format: 0x00 (account version) || ripemd160(sha256(pubkey)) || checksum (4 bytes)
    Checksum: first 4 bytes of double-sha256(version || account_id)
    Encoding: base58 with XRP alphabet (leading 'r' characters for zero bytes).

    Reference: https://xrpl.org/docs/references/protocol/data-types/base58-encodings
    """
    ripe = ripemd160_of_sha256(compressed_pubkey)
    version = b"\x00"
    payload = version + ripe
    chk = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    return base58_encode_check(payload + chk, XRP_ALPHABET)


# ═══════════════════════════════════════════════════════════════════════════════
# Tezos — ed25519 → base58check with tz1 prefix
# ═══════════════════════════════════════════════════════════════════════════════


def tezos_tz1_address(ed25519_pubkey: bytes) -> str:
    """Encode an ed25519 public key as a Tezos tz1 address.

    Format: prefix (4 bytes, 0x00006c5b for tz1_ed25519) || pubkey (32 bytes) || checksum (4 bytes)
    Checksum: double-bip-340 hash (similar to BTC base58check).

    Reference: https://gitlab.com/tezos/tezos/-/blob/master/src/lib_crypto/base58.ml
    """
    if len(ed25519_pubkey) != 32:
        raise ValueError(f"ed25519 pubkey must be 32 bytes, got {len(ed25519_pubkey)}")
    # tz1: 6 bytes 0x00 + 0x06 + 0xc5 + 0x5b... actually 4-byte prefix for tz1_ed25519:
    # 0x00006c5b (literal big-endian)
    # Actually: prefix is 0x06 0xc1 0x5b ... let me use the standard
    # Tezos tz1 ed25519 prefix (4 bytes): 0x06, 0xa1, 0x9f, 0x15 ... this is wrong
    # Real tz1_ed25519 prefix bytes: 0x06, 0xa1, 0x9f, 0x15 (from base58 docs)
    # Let me use the official pytezos encoding: prefix "tz1" -> bytes [0x06, 0xa1, 0x9f, 0x15]
    # Actually it's [0x06, 0xc1, 0x5b, 0x0b] for tz1 ed25519 in the current spec
    # Reference implementation:
    # https://github.com/baking-bad/tzkt/blob/master/Tzkt.Data/Models/Address.cs
    # Wait — the simplest is to use Tezos' own base58 encoding. Since pytezos doesn't
    # work on Python 3.12, we implement it manually.
    #
    # Tezos base58 is identical to BTC base58 (alphabet b'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz')
    # Prefix for tz1_ed25519: bytes [0x06, 0xc1, 0x5b, 0x0b] — actually that's wrong too
    # From Tezos source (Cryptobox/Public_key_hash.ml):
    #   Ed25519 public key hash: 0x06, 0xa1, 0x9f, 0x15 ... no
    # Actually: tz1 prefix bytes = [0x06, 0xc1, 0x5b]  -- that's 3 bytes only
    # Let me just look at a known example:
    #   edpk... public key -> tz1...
    #   hash = blake2b(pubkey, 20)  -- BLAKE2b-160
    #   address = base58(prefix(3 bytes) + hash(20 bytes) + checksum(4 bytes))
    BTC_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

    # Compute the public key hash (BLAKE2b-160)
    pkh = hashlib.blake2b(ed25519_pubkey, digest_size=20).digest()
    # tz1 prefix bytes (from Tezos source): 0x06, 0xc1, 0x5b (3 bytes)
    watermark = bytes([0x06, 0xA1, 0x9F])
    payload = watermark + pkh
    # Checksum: double-sha256, first 4 bytes
    chk = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    return base58_encode_check(payload + chk, BTC_ALPHABET)


# ═══════════════════════════════════════════════════════════════════════════════
# TON — ed25519 → 36-byte address with workchain + CRC16
# ═══════════════════════════════════════════════════════════════════════════════


def ton_address_v4r2(ed25519_pubkey: bytes, workchain: int = 0) -> str:
    """Encode an ed25519 public key as a TON v4r2 wallet address.

    Format: tag (1 byte, 0x11 for bounceable mainnet)
            + workchain (1 byte, signed)
            + hash (32 bytes)
            + crc16-ccitt (2 bytes)
    Total: 36 bytes. Encoded as base64url (no padding).

    For v4r2 wallets, the "hash" is just the 32-byte ed25519 public key.
    For raw contracts, hash = sha256(code). v4r2 wallets sign with ed25519.

    Bounce flag variants: 0x11 = bounceable, 0x51 = non-bounceable,
                         0x91 = bounceable testnet, 0xd1 = non-bounceable testnet.

    Reference: https://docs.ton.org/v3/guidelines/smart-contracts/howto/wallet#wallet-v4
    """
    if len(ed25519_pubkey) != 32:
        raise ValueError(f"ed25519 pubkey must be 32 bytes, got {len(ed25519_pubkey)}")
    # workchain is a signed 8-bit int; mainnet = 0, testnet = -1 (0xff)
    wc_byte = workchain & 0xFF
    addr_bytes = bytes([0x11, wc_byte]) + ed25519_pubkey
    chk = crc16_ccitt(addr_bytes).to_bytes(2, "big")
    full = addr_bytes + chk
    return base64.urlsafe_b64encode(full).decode().rstrip("=")


# ═══════════════════════════════════════════════════════════════════════════════
# Filecoin — secp256k1 → f1 + base32 + blake2b checksum
# ═══════════════════════════════════════════════════════════════════════════════


def filecoin_f1_address(compressed_pubkey: bytes) -> str:
    """Encode a secp256k1 compressed public key as a Filecoin f1 address.

    Format: 'f1' + base32(uncompressed_pubkey_blake2b_4_byte_checksum)

    The payload is the uncompressed secp256k1 public key (65 bytes: 0x04 || X || Y),
    base32 encoded (RFC 4648, lowercase, no padding), with the first 4 bytes of
    blake2b-256(payload) appended as a checksum.

    Reference: https://spec.filecoin.io/address/address/
    """
    # Decompress secp256k1 (33 bytes compressed → 65 bytes uncompressed)
    from coincurve import PublicKey
    if len(compressed_pubkey) == 33:
        uncompressed = PublicKey(compressed_pubkey).format(compressed=False)
    else:
        uncompressed = compressed_pubkey
    # Checksum = blake2b-256(payload)[:4]
    chk = hashlib.blake2b(uncompressed, digest_size=32).digest()[:4]
    body = uncompressed + chk
    # base32 lowercase, no padding
    return "f1" + base64.b32encode(body).decode().lower().rstrip("=")


# ═══════════════════════════════════════════════════════════════════════════════
# Nano — ed25519 → nano_ + base32 (blake2b-40 checksum)
# ═══════════════════════════════════════════════════════════════════════════════


def nano_address(ed25519_pubkey: bytes) -> str:
    """Encode an ed25519 public key as a Nano address.

    Format: 'nano_' + base32(pubkey || blake2b-40(pubkey), no padding)

    The address is the public key plus its blake2b-40 (5-byte) checksum,
    base32-encoded lowercase, prefixed with 'nano_'.

    Reference: https://docs.nano.org/protocol-design/addresses/
    """
    if len(ed25519_pubkey) != 32:
        raise ValueError(f"ed25519 pubkey must be 32 bytes, got {len(ed25519_pubkey)}")
    # Checksum: blake2b with 5-byte digest
    chk = hashlib.blake2b(ed25519_pubkey, digest_size=5).digest()
    body = ed25519_pubkey + chk
    # base32 lowercase, no padding (60 chars total)
    return "nano_" + base64.b32encode(body).decode().lower().rstrip("=")


# ═══════════════════════════════════════════════════════════════════════════════
# Algorand — ed25519 → 58-char base32 with 4-byte checksum
# ═══════════════════════════════════════════════════════════════════════════════


def algorand_address(ed25519_pubkey: bytes) -> str:
    """Encode an ed25519 public key as an Algorand address.

    Format: pubkey (32 bytes) || checksum (4 bytes)
    Total: 36 bytes → 58 base32 chars (RFC 4648, no padding).
    Note: NO version byte. The pubkey itself is hashed directly.

    Checksum = last 4 bytes of sha512(sha512(pubkey)).

    Reference: https://developer.algorand.org/docs/get-details/accounts/#keys-and-addresses
    """
    if len(ed25519_pubkey) != 32:
        raise ValueError(f"ed25519 pubkey must be 32 bytes, got {len(ed25519_pubkey)}")
    # Algorand uses SHA-512/256 (truncated SHA-512 to 256 bits), NOT full SHA-512.
    # The first 32 bytes of SHA-512/256 are taken; we use the last 4 of those as checksum.
    sha512_256 = hashlib.new("sha512_256")
    sha512_256.update(ed25519_pubkey)
    chk = sha512_256.digest()[-4:]
    return base64.b32encode(ed25519_pubkey + chk).decode().rstrip("=")


# ═══════════════════════════════════════════════════════════════════════════════
# Monero — uses the official monero library. NOT derived from BIP39.
# ═══════════════════════════════════════════════════════════════════════════════


def monero_address(seed32_hex: str) -> str:
    """Derive a Monero address from a 32-byte hex seed.

    IMPORTANT: This is a non-standard derivation. Real Monero uses its own 25-word
    mnemonic. To support BIP39 → Monero deterministically, we hash the BIP39
    seed to produce a 32-byte seed, then feed that to the Monero Seed constructor.

    The user can regenerate the same address by running the same BIP39 seed through
    SHA-256 and passing the result to the monero library. The library uses
    Keccak-256 internally to derive spend/view keys.

    Returns a Mainnet address starting with '4' (95 characters).

    Reference: https://www.getmonero.org/resources/developer-guides/wallet-rpc.html
    """
    if len(seed32_hex) != 64:
        raise ValueError(f"seed32_hex must be 64 hex chars (32 bytes), got {len(seed32_hex)}")
    from monero.seed import Seed
    s = Seed(seed32_hex)
    return str(s.public_address())


# ═══════════════════════════════════════════════════════════════════════════════
# Substrate (Polkadot/Kusama) — sr25519, requires substrate-interface
# ═══════════════════════════════════════════════════════════════════════════════


def substrate_ss58_address(mnemonic: str, ss58_prefix: int) -> str:
    """Derive a Substrate SS58 address from a BIP39 mnemonic using sr25519.

    Args:
        mnemonic: BIP39 mnemonic (12 or 24 words).
        ss58_prefix: Network identifier (0 = Polkadot, 2 = Kusama, 42 = generic Substrate).

    Note: Substrate addresses use sr25519, NOT ed25519 or secp256k1. We can't
    reuse the BIP32 derivation from bip_utils here — substrate-interface uses
    its own keypair generation from the mnemonic.

    Reference: https://docs.substrate.io/v3/advanced/ss58/
    """
    from substrateinterface import Keypair
    kp = Keypair.create_from_uri(mnemonic, ss58_format=ss58_prefix)
    return kp.ss58_address


# ═══════════════════════════════════════════════════════════════════════════════
# Bitcoin Cash — uses bitcash for cashaddr format
# ═══════════════════════════════════════════════════════════════════════════════


def bitcoin_cash_cashaddr(privkey_bytes: bytes) -> str:
    """Encode a secp256k1 private key as a Bitcoin Cash cashaddr address.

    Format: 'bitcoincash:' + cashaddr(pubkey_hash, type=p2pkh)

    cashaddr encoding: https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
    """
    from bitcash import PrivateKey
    return PrivateKey.from_bytes(privkey_bytes).address


# ═══════════════════════════════════════════════════════════════════════════════
# Zcash transparent — secp256k1 with proper t-addr prefix
# ═══════════════════════════════════════════════════════════════════════════════


def zcash_t_address(compressed_pubkey: bytes) -> str:
    """Encode a secp256k1 compressed public key as a Zcash transparent t-address.

    Format (zatoshi t-addr):
        version (2 bytes, 0x1C 0xB8 for p2pkh)
        || hash160(pubkey) (20 bytes)
        || checksum (4 bytes, double-sha256 first 4 bytes)
    Encoded with Bitcoin base58 alphabet.

    Reference: https://zips.z.cash/protocol/protocol.pdf §5.6.1
    The original buggy code used prefix 0x1C (single byte, BTC style) which
    produces invalid Zcash addresses. The correct t-addr prefix is [0x1C, 0xB8].
    """
    ripe = ripemd160_of_sha256(compressed_pubkey)
    version = bytes([0x1C, 0xB8])
    payload = version + ripe
    chk = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
    return base58_encode_check(payload + chk, b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")


# ═══════════════════════════════════════════════════════════════════════════════
# Dispatch table — used by generator.py
# ═══════════════════════════════════════════════════════════════════════════════


# Map from chain key to (family, encoder_function, encoder_args)
# The encoder receives whatever the generator already has at hand.
ADDRESS_ENCODERS = {
    # Cosmos family
    "atom": ("bech32", "cosmos"),
    "osmo": ("bech32", "osmo"),
    "juno": ("bech32", "juno"),
    "sei":  ("bech32", "sei"),
    "evmos": ("bech32", "evmos"),
    "inj":  ("bech32", "inj"),
    # Stellar / XRP / Tezos / TON / Filecoin / Nano / Algorand / Monero
    "xlm": ("stellar", None),
    "xrp": ("xrp", None),
    "xtz": ("tezos", None),
    "ton": ("ton", None),
    "fil": ("filecoin", None),
    "xno": ("nano", None),
    "algo": ("algorand", None),
    # Monero + Substrate need the full key derivation context, not just pubkey
    "xmr": ("monero", None),
    "dot": ("substrate", 0),   # ss58_prefix
    "ksm": ("substrate", 2),
    # BCH
    "bch": ("bch", None),
}


def encode_address(family: str, *args) -> str:
    """Dispatch to the right encoder.

    Args:
        family: One of "bech32", "stellar", "xrp", "tezos", "ton",
                "filecoin", "nano", "algorand", "monero", "substrate", "bch".
        *args: Positional args for the encoder:
               - bech32: (compressed_pubkey, hrp)
               - stellar: (ed25519_pubkey)
               - xrp: (compressed_pubkey)
               - tezos: (ed25519_pubkey)
               - ton: (ed25519_pubkey)
               - filecoin: (compressed_pubkey)
               - nano: (ed25519_pubkey)
               - algorand: (ed25519_pubkey)
               - monero: (seed32_hex)
               - substrate: (mnemonic, ss58_prefix)
               - bch: (privkey_bytes)
    """
    if family == "bech32":
        return cosmos_address(args[0], args[1])
    if family == "stellar":
        return stellar_address(args[0])
    if family == "xrp":
        return xrp_address(args[0])
    if family == "tezos":
        return tezos_tz1_address(args[0])
    if family == "ton":
        return ton_address_v4r2(args[0])
    if family == "filecoin":
        return filecoin_f1_address(args[0])
    if family == "nano":
        return nano_address(args[0])
    if family == "algorand":
        return algorand_address(args[0])
    if family == "monero":
        return monero_address(args[0])
    if family == "substrate":
        return substrate_ss58_address(args[0], args[1])
    if family == "bch":
        return bitcoin_cash_cashaddr(args[0])
    if family == "zcash_t":
        return zcash_t_address(args[0])
    raise ValueError(f"Unknown address family: {family}")