libcrypto 1.0.1__py3-none-any.whl

libcrypto/__init__.py

@@ -0,0 +1,72 @@
+"""
+LibCrypto Wallet Module
+
+This module provides comprehensive cryptocurrency wallet functionality including:
+- BIP32 Hierarchical Deterministic (HD) wallets
+- Multi-currency address generation
+- Key format conversions
+- WIF (Wallet Import Format) support
+"""
+from .wallet import Wallet
+from .bip32 import HDWallet, HDNode, BIP32Error
+from .keys import PrivateKey, PublicKey, KeyError
+from .mnemonic import (
+    generate_mnemonic,
+    validate_mnemonic,
+    mnemonic_to_seed,
+    mnemonic_to_entropy,
+    entropy_to_mnemonic,
+    InvalidMnemonicError,
+    InvalidEntropyError
+)
+from .addresses import AddressGenerator, AddressError
+from .formats import (
+    private_key_to_wif,
+    wif_to_private_key,
+    base58_encode,
+    base58_decode,
+    bytes_to_hex,
+    hex_to_bytes,
+    InvalidFormatError
+)
+
+__version__ = "1.0.1"
+__all__ = [
+    # Library Version
+    '__version__',
+
+    # High-Level Wallet
+    'Wallet',
+
+    # HD Wallet
+    'HDWallet',
+    'HDNode',
+    'BIP32Error',
+
+    # Key classes
+    'PrivateKey',
+    'PublicKey',
+    'KeyError',
+
+    # Address generation
+    'AddressGenerator',
+    'AddressError',
+
+    # Format conversions
+    'private_key_to_wif',
+    'wif_to_private_key',
+    'base58_encode',
+    'base58_decode',
+    'bytes_to_hex',
+    'hex_to_bytes',
+    'InvalidFormatError',
+
+    # Mnemonic functions
+    'generate_mnemonic',
+    'validate_mnemonic',
+    'mnemonic_to_seed',
+    'mnemonic_to_entropy',
+    'entropy_to_mnemonic',
+    'InvalidMnemonicError',
+    'InvalidEntropyError'
+]

libcrypto/_version.py

@@ -0,0 +1,19 @@
+"""
+Version information for LibCrypto package.
+This is the single source of truth for version numbers, managed by bump-my-version.
+
+Requires Python 3.8+
+"""
+
+__author__ = "Mmdrza"
+__author_email__ = "pymmdrza@gmail.com"
+__description__ = (
+    "A professional library For Cryptography and Cryptocurrencies in Python."
+)
+__url__ = "https://github.com/Pymmdrza/libcrypto"
+# version Libcrypto
+__version__ = "1.0.0"
+
+# Additional metadata
+__license__ = "MIT"
+__copyright__ = "2025 Mmdrza"

libcrypto/addresses.py

@@ -0,0 +1,191 @@
+"""
+Cryptocurrency Address Generation
+
+This module provides address generation functionality for multiple cryptocurrencies
+including Bitcoin, Ethereum, Litecoin, and others. Supports various address formats
+like P2PKH, P2SH, P2WPKH, SegWit, and Ethereum-style addresses.
+"""
+from typing import Union
+
+from .hash import sha256, hash160, keccak256
+from .constants import ADDRESS_VERSIONS, BECH32_HRP
+from .formats import base58_check_encode, base58_encode, InvalidFormatError
+from .secp256k1 import public_key_to_point_coords, Secp256k1Error
+
+
+class AddressError(ValueError):
+    """Raised when address generation fails."""
+    pass
+
+
+class Bech32:
+    """Bech32 encoding/decoding for SegWit addresses."""
+    CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    BECH32_CONST = 1
+
+    @classmethod
+    def _polymod(cls, values):
+        GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+        chk = 1
+        for value in values:
+            top = chk >> 25
+            chk = (chk & 0x1ffffff) << 5 ^ value
+            for i in range(5):
+                chk ^= GEN[i] if ((top >> i) & 1) else 0
+        return chk
+
+    @classmethod
+    def _hrp_expand(cls, hrp):
+        return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
+
+    @classmethod
+    def _create_checksum(cls, hrp, data):
+        values = cls._hrp_expand(hrp) + data
+        polymod = cls._polymod(values + [0, 0, 0, 0, 0, 0]) ^ cls.BECH32_CONST
+        return [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
+
+    @classmethod
+    def encode(cls, hrp, data):
+        combined = data + cls._create_checksum(hrp, data)
+        return hrp + '1' + ''.join([cls.CHARSET[d] for d in combined])
+
+    @classmethod
+    def convert_bits(cls, data, frombits, tobits, pad=True):
+        acc, bits, ret, maxv = 0, 0, [], (1 << tobits) - 1
+        for value in data:
+            if value < 0 or (value >> frombits):
+                return None
+            acc = (acc << frombits) | value
+            bits += frombits
+            while bits >= tobits:
+                bits -= tobits
+                ret.append((acc >> bits) & maxv)
+        if pad and bits:
+            ret.append((acc << (tobits - bits)) & maxv)
+        elif not pad and (bits >= frombits or ((acc << (tobits - bits)) & maxv)):
+            return None
+        return ret
+
+
+class AddressGenerator:
+    """
+    Address generator for multiple cryptocurrencies.
+    """
+
+    @classmethod
+    def from_public_key(cls, public_key: bytes, address_type: str, network: str) -> str:
+        """
+        Generate address from a public key.
+        """
+        if network == 'ethereum':
+            return cls._generate_ethereum_address(public_key)
+        elif network == 'tron':
+            return cls._generate_tron_address(public_key)
+        elif network == 'ripple':
+            return cls._generate_ripple_address(public_key)
+        elif network in ('solana', 'ton'):
+            # These networks use Ed25519, which is a different curve.
+            # Providing a secp256k1 key will result in an invalid address.
+            raise NotImplementedError(
+                f"{network.capitalize()} uses the Ed25519 curve. "
+                "Address generation from secp256k1 keys is not supported and would be incorrect."
+            )
+        else:
+            return cls._generate_bitcoin_style_address(public_key, address_type, network)
+
+    @classmethod
+    def _generate_bitcoin_style_address(cls, public_key: bytes, address_type: str, network: str) -> str:
+        """Generate Bitcoin-like addresses (P2PKH, P2SH, SegWit)."""
+        if network not in ADDRESS_VERSIONS:
+            raise AddressError(f"Unsupported network: {network}")
+
+        versions = ADDRESS_VERSIONS[network]
+        key_hash = hash160(public_key)
+
+        if address_type == 'p2pkh':
+            versioned_payload = bytes([versions['p2pkh']]) + key_hash
+            return base58_check_encode(versioned_payload)
+
+        elif address_type == 'p2sh-p2wpkh':
+            # P2SH-wrapped SegWit address (for compatibility)
+            redeem_script = b'\x00\x14' + key_hash
+            script_hash = hash160(redeem_script)
+            versioned_payload = bytes([versions['p2sh']]) + script_hash
+            return base58_check_encode(versioned_payload)
+
+        elif address_type == 'p2wpkh':
+            # Native SegWit (Bech32)
+            if network not in BECH32_HRP:
+                raise AddressError(f"SegWit (Bech32) not supported for network: {network}")
+
+            converted = Bech32.convert_bits(key_hash, 8, 5)
+            if converted is None:
+                raise AddressError("Failed to convert bits for Bech32 encoding.")
+
+            return Bech32.encode(BECH32_HRP[network], [0] + converted)
+
+        else:
+            raise AddressError(f"Unsupported address type for {network}: {address_type}")
+
+    @classmethod
+    def _get_uncompressed_pubkey(cls, public_key: bytes) -> bytes:
+        """Ensures the public key is in uncompressed format (64 bytes, no prefix)."""
+        if len(public_key) == 33:  # Compressed
+            try:
+                point = public_key_to_point_coords(public_key)
+                return point.x.to_bytes(32, 'big') + point.y.to_bytes(32, 'big')
+            except Exception as e:
+                raise AddressError(f"Failed to decompress public key: {e}")
+        elif len(public_key) == 65 and public_key[0] == 0x04:  # Uncompressed with prefix
+            return public_key[1:]
+        elif len(public_key) == 64:  # Uncompressed without prefix
+            return public_key
+        else:
+            raise AddressError(f"Invalid public key length for this operation: {len(public_key)}")
+
+    @classmethod
+    def _generate_ethereum_address(cls, public_key: bytes) -> str:
+        """Generate Ethereum address (with EIP-55 checksum)."""
+        uncompressed_key = cls._get_uncompressed_pubkey(public_key)
+
+        keccak_hash = keccak256(uncompressed_key)
+        address_bytes = keccak_hash[-20:]
+        address_hex = address_bytes.hex()
+
+        # EIP-55 checksum
+        checksum_hash = keccak256(address_hex.encode('ascii')).hex()
+        checksummed = '0x'
+        for i, char in enumerate(address_hex):
+            if int(checksum_hash[i], 16) >= 8:
+                checksummed += char.upper()
+            else:
+                checksummed += char
+        return checksummed
+
+    @classmethod
+    def _generate_tron_address(cls, public_key: bytes) -> str:
+        """Generate TRON address."""
+        uncompressed_key = cls._get_uncompressed_pubkey(public_key)
+
+        keccak_hash = keccak256(uncompressed_key)
+        address_bytes = b'\x41' + keccak_hash[-20:]  # TRON prefix 0x41
+
+        return base58_check_encode(address_bytes)
+
+    @classmethod
+    def _generate_ripple_address(cls, public_key: bytes) -> str:
+        """Generate Ripple (XRP) address."""
+        # Ripple requires a compressed public key
+        if len(public_key) == 65:
+            from .secp256k1 import compress_public_key
+            public_key = compress_public_key(public_key)
+
+        if len(public_key) != 33:
+            raise AddressError(f"Invalid public key length for Ripple: {len(public_key)}")
+
+        key_hash = hash160(public_key)
+        versioned_payload = b'\x00' + key_hash  # Ripple account ID prefix
+
+        # Ripple uses a specific Base58 alphabet
+        ripple_alphabet = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"
+        return base58_check_encode(versioned_payload, alphabet=ripple_alphabet)

libcrypto/bip32.py

@@ -0,0 +1,234 @@
+"""
+BIP32 Hierarchical Deterministic (HD) Wallet Implementation
+
+This module provides BIP32 compliant hierarchical deterministic wallet functionality
+including master key generation from seed, child key derivation, and extended key
+serialization (xprv/xpub format).
+"""
+import struct
+from typing import Optional
+
+from .constants import (
+    BIP32_HARDENED_OFFSET, BIP32_HMAC_KEY, XPRV_MAINNET, XPUB_MAINNET,
+    XPRV_TESTNET, XPUB_TESTNET, SECP256K1_N
+)
+from .formats import base58_check_encode, base58_check_decode, InvalidFormatError
+from .hash import hmac_sha512, hash160
+from .secp256k1 import private_key_to_public_key
+
+
+class BIP32Error(ValueError):
+    """Raised when BIP32 operations fail."""
+    pass
+
+
+class HDNode:
+    """A single node in a BIP32 hierarchical deterministic wallet tree."""
+
+    def __init__(self, private_key: Optional[bytes], chain_code: bytes,
+                 depth: int = 0, parent_fingerprint: bytes = b'\x00\x00\x00\x00',
+                 child_number: int = 0, network: str = 'mainnet'):
+
+        if len(chain_code) != 32:
+            raise BIP32Error(f"Chain code must be 32 bytes, got {len(chain_code)}")
+        if private_key and len(private_key) != 32:
+            raise BIP32Error(f"Private key must be 32 bytes, got {len(private_key)}")
+
+        self._private_key = private_key
+        self.chain_code = chain_code
+        self.depth = depth
+        self.parent_fingerprint = parent_fingerprint
+        self.child_number = child_number
+        self.network = network
+
+        self._public_key = None
+        if self._private_key:
+            self._derive_public_from_private()
+
+    def _derive_public_from_private(self):
+        private_int = int.from_bytes(self._private_key, 'big')
+        self._public_key = private_key_to_public_key(private_int, compressed=True)
+
+    @property
+    def private_key(self) -> Optional[bytes]:
+        return self._private_key
+
+    @property
+    def public_key(self) -> bytes:
+        if self._public_key is None:
+            # This case is for public-only derivation which is not implemented.
+            raise BIP32Error("Public key not available or derivation from public key is not supported.")
+        return self._public_key
+
+    @property
+    def is_private(self) -> bool:
+        return self._private_key is not None
+
+    @property
+    def fingerprint(self) -> bytes:
+        return hash160(self.public_key)[:4]
+
+    def derive_child(self, index: int) -> 'HDNode':
+        """Derive a child key at the given index."""
+        is_hardened = index >= BIP32_HARDENED_OFFSET
+
+        if is_hardened:
+            if not self.is_private:
+                raise BIP32Error("Cannot derive hardened child from a public key.")
+            data = b'\x00' + self._private_key + struct.pack('>I', index)
+        else:
+            # Public key derivation is complex (point addition).
+            # We will only support private key derivation for simplicity and security.
+            if not self.is_private:
+                raise BIP32Error("Derivation from public-only node is not supported.")
+            data = self.public_key + struct.pack('>I', index)
+
+        hmac_result = hmac_sha512(self.chain_code, data)
+        child_key_material, child_chain_code = hmac_result[:32], hmac_result[32:]
+
+        child_key_int = int.from_bytes(child_key_material, 'big')
+        parent_key_int = int.from_bytes(self._private_key, 'big')
+
+        derived_private_int = (child_key_int + parent_key_int) % SECP256K1_N
+        if derived_private_int == 0:
+            # In the rare case of an invalid key, BIP32 suggests trying the next index.
+            # For simplicity, we raise an error.
+            raise BIP32Error("Invalid child key generated, leads to key being zero.")
+
+        child_private_key = derived_private_int.to_bytes(32, 'big')
+
+        return HDNode(
+            private_key=child_private_key,
+            chain_code=child_chain_code,
+            depth=self.depth + 1,
+            parent_fingerprint=self.fingerprint,
+            child_number=index,
+            network=self.network
+        )
+
+    def derive_path(self, path: str) -> 'HDNode':
+        """Derive a key using a derivation path string (e.g., "m/44'/0'/0'")."""
+        if path == "m" or path == "/":
+            return self
+        if path.startswith(('m/', '/')):
+            path = path[2:]
+
+        node = self
+        for segment in path.split('/'):
+            if not segment: continue
+
+            hardened = segment.endswith("'")
+            index_str = segment[:-1] if hardened else segment
+
+            try:
+                index = int(index_str)
+                if hardened:
+                    index += BIP32_HARDENED_OFFSET
+            except ValueError:
+                raise BIP32Error(f"Invalid path segment: {segment}")
+
+            node = node.derive_child(index)
+
+        return node
+
+    def serialize_private(self) -> str:
+        """Serialize as an extended private key (xprv)."""
+        if not self.is_private:
+            raise BIP32Error("Cannot serialize a private key from a public-only node.")
+
+        version = XPRV_MAINNET if self.network == 'mainnet' else XPRV_TESTNET
+
+        data = struct.pack('>I', version)
+        data += bytes([self.depth])
+        data += self.parent_fingerprint
+        data += struct.pack('>I', self.child_number)
+        data += self.chain_code
+        data += b'\x00' + self._private_key
+
+        return base58_check_encode(data)
+
+    def serialize_public(self) -> str:
+        """Serialize as an extended public key (xpub)."""
+        version = XPUB_MAINNET if self.network == 'mainnet' else XPUB_TESTNET
+
+        data = struct.pack('>I', version)
+        data += bytes([self.depth])
+        data += self.parent_fingerprint
+        data += struct.pack('>I', self.child_number)
+        data += self.chain_code
+        data += self.public_key
+
+        return base58_check_encode(data)
+
+    @classmethod
+    def deserialize(cls, extended_key: str) -> 'HDNode':
+        """Deserialize an extended key (xprv) to an HDNode."""
+        try:
+            data = base58_check_decode(extended_key)
+        except InvalidFormatError as e:
+            raise BIP32Error(f"Invalid extended key format: {e}") from e
+
+        if len(data) != 78:
+            raise BIP32Error(f"Extended key must be 78 bytes, got {len(data)}")
+
+        version = struct.unpack('>I', data[:4])[0]
+
+        if version not in [XPRV_MAINNET, XPRV_TESTNET]:
+            raise BIP32Error("Deserialization of public extended keys (xpub) is not supported.")
+
+        network = 'mainnet' if version == XPRV_MAINNET else 'testnet'
+
+        depth = data[4]
+        parent_fingerprint = data[5:9]
+        child_number = struct.unpack('>I', data[9:13])[0]
+        chain_code = data[13:45]
+
+        if data[45] != 0x00:
+            raise BIP32Error("Private key must be prefixed with 0x00.")
+        private_key = data[46:78]
+
+        return cls(
+            private_key=private_key,
+            chain_code=chain_code,
+            depth=depth,
+            parent_fingerprint=parent_fingerprint,
+            child_number=child_number,
+            network=network
+        )
+
+
+class HDWallet:
+    """BIP32 Hierarchical Deterministic Wallet."""
+
+    def __init__(self, seed: bytes, network: str = 'mainnet'):
+        self.network = network
+        self._master_node = self._generate_master_node(seed)
+
+    def _generate_master_node(self, seed: bytes) -> HDNode:
+        hmac_result = hmac_sha512(BIP32_HMAC_KEY, seed)
+        master_private_key, master_chain_code = hmac_result[:32], hmac_result[32:]
+
+        private_int = int.from_bytes(master_private_key, 'big')
+        if not (1 <= private_int < SECP256K1_N):
+            raise BIP32Error("Invalid master key generated from seed (out of curve order).")
+
+        return HDNode(
+            private_key=master_private_key,
+            chain_code=master_chain_code,
+            network=self.network
+        )
+
+    @property
+    def master_node(self) -> HDNode:
+        return self._master_node
+
+    def derive_from_path(self, path: str) -> HDNode:
+        """Derive a node from a full BIP32 path."""
+        return self._master_node.derive_path(path)
+
+    @classmethod
+    def from_mnemonic(cls, mnemonic: str, passphrase: str = "", network: str = 'mainnet') -> 'HDWallet':
+        """Create HDWallet from a BIP39 mnemonic."""
+        from .mnemonic import mnemonic_to_seed
+        seed = mnemonic_to_seed(mnemonic, passphrase)
+        return cls(seed, network)

libcrypto/cli.py

@@ -0,0 +1,159 @@
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from typing import List, Optional
+
+from . import __version__
+from .wallet import Wallet, COIN_CONFIG
+from .mnemonic import generate_mnemonic, validate_mnemonic
+
+# Create a Typer application instance. This is the main entry point for commands.
+app = typer.Typer(
+    name="libcrypto",
+    help="A professional library for Cryptography and Cryptocurrencies.",
+    add_completion=False,
+)
+
+# Create a rich Console instance for beautiful output.
+console = Console()
+
+
+def version_callback(value: bool):
+    """Callback function to display the version and exit."""
+    if value:
+        console.print(f"libcrypto version: [bold green]{__version__}[/bold green]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+        version: bool = typer.Option(
+            None,
+            "--version",
+            "-v",
+            help="Show the application's version and exit.",
+            callback=version_callback,
+            is_eager=True,
+        )
+):
+    """
+    LibCrypto CLI: Manage crypto keys, addresses, and mnemonics.
+    """
+    # This main function serves as a top-level entry point.
+    # The 'version_callback' handles the --version flag.
+    pass
+
+
+@app.command()
+def info():
+    """
+    Display information about the libcrypto package.
+    """
+    info_text = (
+        f"[bold]libcrypto v{__version__}[/bold]\n"
+        "[dim]A professional library for Cryptography and Cryptocurrencies in Python.[/dim]\n\n"
+        "Author: [cyan]Mmdrza[/cyan]\n"
+        "Repository: [link=https://github.com/Pymmdrza/libcrypto]https://github.com/Pymmdrza/libcrypto[/link]"
+    )
+    panel = Panel(info_text, title="Package Information", border_style="blue", expand=False)
+    console.print(panel)
+
+
+@app.command()
+def generate(
+        private_key: Optional[str] = typer.Option(
+            None,
+            "--private-key",
+            "-p",
+            help="Generate addresses from an existing private key (WIF or Hex).",
+        ),
+        coins: List[str] = typer.Option(
+            ["bitcoin", "ethereum", "tron", "ripple", "litecoin", "dogecoin", "dash", "bitcoin_cash"],
+            "--coin",
+            "-c",
+            help="Specify coin(s) to generate addresses for. Can be used multiple times.",
+        ),
+):
+    """
+    Generate a new wallet or derive addresses from an existing private key.
+    """
+    try:
+        if private_key:
+            wallet = Wallet(private_key)
+            console.print(Panel("Addresses derived from your provided private key",
+                                title="[bold yellow]Wallet Details[/bold yellow]", border_style="yellow"))
+        else:
+            wallet = Wallet.generate()
+            console.print(Panel("A new secure wallet has been generated for you!",
+                                title="[bold green]New Wallet Created[/bold green]", border_style="green"))
+
+        # --- Display Keys ---
+        key_table = Table(title="Crypto Wallet Detail", show_header=False, box=None)
+        key_table.add_column("Attribute", style="cyan")
+        key_table.add_column("Value", style="white")
+
+        key_table.add_row("Private Key (Hex)", wallet.private_key.hex)
+        key_table.add_row("Private Key (WIF)", wallet.private_key.to_wif())
+        key_table.add_row("Public Key (Compressed)", wallet._public_key_compressed.hex)
+        key_table.add_row("Public Key (Uncompressed)", wallet._public_key_uncompressed.hex)
+        console.print(key_table)
+
+        # --- Display Addresses ---
+        address_table = Table(title="Generated Addresses", box=None)
+        address_table.add_column("Coin", style="bold magenta")
+        address_table.add_column("Address Type", style="yellow")
+        address_table.add_column("Address", style="bold green")
+
+        for coin in coins:
+            coin = coin.lower()
+            if coin not in COIN_CONFIG:
+                console.print(f"[bold red]Error:[/] Unsupported coin '{coin}'. Skipping.")
+                continue
+
+            addresses = wallet.get_all_addresses(coin)
+            for addr_type, address in addresses.items():
+                address_table.add_row(coin.capitalize(), addr_type, address)
+
+        console.print(address_table)
+
+    except Exception as e:
+        console.print(f"[bold red]An error occurred:[/] {e}")
+        raise typer.Exit(code=1)
+
+
+# --- Mnemonic Sub-Commands ---
+mnemonic_app = typer.Typer(name="mnemonic", help="Generate and validate BIP39 mnemonic phrases.")
+app.add_typer(mnemonic_app, name="mnemonic")
+
+
+@mnemonic_app.command("generate")
+def mnemonic_generate(
+        word_count: int = typer.Option(12, "--words", "-w",
+                                       help="Number of words for the mnemonic (12, 15, 18, 21, or 24).")
+):
+    """
+    Generate a new BIP39 mnemonic phrase.
+    """
+    try:
+        mnemonic = generate_mnemonic(word_count)
+        console.print(
+            Panel(f"[bold cyan]{mnemonic}[/bold cyan]", title="Generated Mnemonic Phrase", border_style="green"))
+    except ValueError as e:
+        console.print(f"[bold red]Error:[/] {e}")
+
+
+@mnemonic_app.command("validate")
+def mnemonic_validate(
+        phrase: str = typer.Argument(..., help="The mnemonic phrase to validate, enclosed in quotes.")
+):
+    """
+    Validate a BIP39 mnemonic phrase.
+    """
+    is_valid = validate_mnemonic(phrase)
+    if is_valid:
+        console.print(Panel("[bold green]This mnemonic phrase is valid.[/bold green]", title="Validation Success",
+                            border_style="green"))
+    else:
+        console.print(Panel("[bold red]This mnemonic phrase is invalid.[/bold red]", title="Validation Failed",
+                            border_style="red"))