xchainpy2_crypto 0.1.1__tar.gz

xchainpy2_crypto-0.1.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Tirinox (aka TRX1 aka account1242 aka Old1)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xchainpy2_crypto-0.1.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: xchainpy2_crypto
+Version: 0.1.1
+Summary: XChainPy2 Crypto utils and keystore management
+Author-email: Tirinox <tirinox@gmail.com>
+License: MIT
+Project-URL: source, https://github.com/tirinox/xchainpy
+Keywords: Crypto,THORChain,Blockchain,XChain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bip-utils<3.0.0,>=2.12.1.0
+Requires-Dist: pycryptodome<4.0,>=3.23
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# How it works
+Typically keystore files encrypt a seed to a file, however this is not appropriate or UX friendly, since the phrase
+cannot be recovered after the fact.
+
+Crypto design:
+
+`[entropy] -> [phrase] -> [seed] -> [privateKey] -> [publicKey] -> [address]`
+
+Instead, XCHAIN-CRYPTO stores the phrase in a keystore file, then decrypts and passes this phrase to other clients:
+
+`[keystore] -> XCHAIN-CRYPTO -> [phrase] -> ChainClient`
+
+The ChainClients can then convert this into their respective key-pairs and addresses. Users can also export their
+phrases after the fact, ensuring they have saved it securely. This could enhance UX onboarding since users aren't forced
+to write their phrases down immediately for empty or test wallets.
+
+### Documentation
+
+👉 https://xchainpy2.readthedocs.io/en/latest/packages/xchainpy2_crypto.html

xchainpy2_crypto-0.1.1/README.md

@@ -0,0 +1,19 @@
+# How it works
+Typically keystore files encrypt a seed to a file, however this is not appropriate or UX friendly, since the phrase
+cannot be recovered after the fact.
+
+Crypto design:
+
+`[entropy] -> [phrase] -> [seed] -> [privateKey] -> [publicKey] -> [address]`
+
+Instead, XCHAIN-CRYPTO stores the phrase in a keystore file, then decrypts and passes this phrase to other clients:
+
+`[keystore] -> XCHAIN-CRYPTO -> [phrase] -> ChainClient`
+
+The ChainClients can then convert this into their respective key-pairs and addresses. Users can also export their
+phrases after the fact, ensuring they have saved it securely. This could enhance UX onboarding since users aren't forced
+to write their phrases down immediately for empty or test wallets.
+
+### Documentation
+
+👉 https://xchainpy2.readthedocs.io/en/latest/packages/xchainpy2_crypto.html

xchainpy2_crypto-0.1.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xchainpy2_crypto"
+version = "0.1.1"
+authors = [
+    { name = "Tirinox", email = "tirinox@gmail.com" },
+]
+description = "XChainPy2 Crypto utils and keystore management"
+readme = "README.md"
+requires-python = ">=3.7"
+keywords = ["Crypto", "THORChain", "Blockchain", "XChain"]
+license = { text = "MIT" }
+urls = { source = "https://github.com/tirinox/xchainpy" }
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    # Chose either "3 - Alpha", "4 - Beta" or "5 - Production/Stable" as the current state of your package
+    'Intended Audience :: Developers', # Define that your audience are developers
+    'Topic :: Software Development :: Build Tools',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.6',
+    'Programming Language :: Python :: 3.7',
+    'Programming Language :: Python :: 3.8',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+]
+dependencies = [
+    "bip-utils>=2.12.1.0,<3.0.0",
+    "pycryptodome>=3.23,<4.0",
+]
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools]
+packages = ["xchainpy2_crypto"]

xchainpy2_crypto-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xchainpy2_crypto-0.1.1/xchainpy2_crypto/__init__.py

@@ -0,0 +1,2 @@
+from .keystore import *
+from .utils import *

xchainpy2_crypto-0.1.1/xchainpy2_crypto/keystore.py

@@ -0,0 +1,174 @@
+import hashlib
+import json
+import uuid
+from os import urandom
+from typing import NamedTuple
+
+from Crypto.Cipher import AES
+from Crypto.Hash import BLAKE2b
+from Crypto.Util import Counter
+
+from .utils import validate_mnemonic, generate_mnemonic
+
+CIPHER = 'aes-128-ctr'
+NBITS = 128
+KDF = 'pbkdf2'
+PRF = 'hmac-sha256'
+DKLEN = 32
+C = 262144
+HASH_FUNCTION = 'sha256'
+META = 'xchain-keystore'
+VERSION = 1
+ENCODING = 'utf-8'
+
+
+class InvalidPasswordException(Exception):
+    pass
+
+
+class KeyStore(NamedTuple):
+    cipher: str
+    ciphertext: str
+    cipherparams_iv: str
+    kdf: str
+    kdfparams_prf: str
+    kdfparams_dklen: int
+    kdfparams_salt: str
+    kdfparams_c: int
+    mac: str
+    id: str
+    version: int
+    meta: str
+
+    @property
+    def to_dict(self):
+        return {
+            'crypto': {
+                'cipher': self.cipher,
+                'ciphertext': self.ciphertext,
+                'cipherparams': {
+                    'iv': self.cipherparams_iv
+                },
+                'kdf': self.kdf,
+                'kdfparams': {
+                    'prf': self.kdfparams_prf,
+                    'dklen': self.kdfparams_dklen,
+                    'salt': self.kdfparams_salt,
+                    'c': self.kdfparams_c
+                },
+                'mac': self.mac,
+            },
+            'id': self.id,
+            'version': self.version,
+            'meta': self.meta
+        }
+
+    @property
+    def to_json(self):
+        return json.dumps(self.to_dict)
+
+    @classmethod
+    def from_dict(cls, j):
+        crypto = j.get('crypto')
+        return cls(
+            cipher=crypto['cipher'],
+            ciphertext=crypto['ciphertext'],
+            cipherparams_iv=crypto['cipherparams']['iv'],
+            kdf=crypto['kdf'],
+            kdfparams_prf=crypto['kdfparams']['prf'],
+            kdfparams_dklen=int(crypto['kdfparams']['dklen']),
+            kdfparams_salt=crypto['kdfparams']['salt'],
+            kdfparams_c=crypto['kdfparams']['c'],
+            mac=crypto['mac'],
+            id=j['id'],
+            version=j['version'],
+            meta=j['meta']
+        )
+
+    @classmethod
+    def from_file(cls, path):
+        with open(path) as f:
+            data = json.load(f)
+            return cls.from_dict(data)
+
+    def save(self, path: str, indent=4):
+        with open(path, 'w') as f:
+            json.dump(self.to_dict, f, indent=indent)
+
+    @classmethod
+    def encrypt_to_keystore(cls, mnemonic: str, password: str):
+        """
+        Encrypts a mnemonic to a keystore with a password
+        :param str mnemonic: BIP39 mnemonic
+        :param str password: Password
+        :return: KeyStore
+        """
+        if not validate_mnemonic(mnemonic):
+            raise Exception("Invalid BIP39 Phrase")
+
+        ID = str(uuid.uuid4())
+        salt = urandom(32)
+        iv = urandom(16).hex()
+
+        derived_key = hashlib.pbkdf2_hmac(
+            HASH_FUNCTION,
+            password.encode(ENCODING),
+            salt,
+            C,
+            DKLEN
+        )
+
+        ctr = Counter.new(NBITS, initial_value=int(iv, 16))
+        aes_cipher = AES.new(derived_key[0:16], AES.MODE_CTR, counter=ctr)
+        cipher_bytes = aes_cipher.encrypt(mnemonic.encode("utf8"))
+
+        blake256 = BLAKE2b.new(digest_bits=256)
+        blake256.update((derived_key[16:32] + cipher_bytes))
+        mac = blake256.hexdigest()
+
+        return cls(
+            cipher=CIPHER,
+            ciphertext=cipher_bytes.hex(),
+            cipherparams_iv=iv,
+            kdf=KDF,
+            kdfparams_prf=PRF,
+            kdfparams_dklen=DKLEN,
+            kdfparams_salt=salt.hex(),
+            kdfparams_c=C,
+            mac=mac,
+            id=ID,
+            version=VERSION,
+            meta=META
+        )
+
+    def decrypt_from_keystore(self, password: str):
+        """
+        Derives a mnemonic from a keystore with a password
+        :param str password: password
+        :return: str Mnemonic phrase
+        """
+        derived_key = hashlib.pbkdf2_hmac(
+            HASH_FUNCTION,
+            password.encode(ENCODING),
+            bytes.fromhex(self.kdfparams_salt),
+            self.kdfparams_c,
+            self.kdfparams_dklen
+        )
+
+        cipher_bytes = bytes.fromhex(self.ciphertext)
+
+        blake256 = BLAKE2b.new(digest_bits=256)
+        blake256.update((derived_key[16:32] + cipher_bytes))
+        mac = blake256.hexdigest()
+        if mac != self.mac:
+            raise InvalidPasswordException("Invalid password")
+
+        ctr = Counter.new(NBITS, initial_value=int(self.cipherparams_iv, 16))
+        aes_cipher = AES.new(derived_key[0:16], AES.MODE_CTR, counter=ctr)
+        phrase = aes_cipher.decrypt(cipher_bytes)
+        return phrase.decode("utf8")
+
+    @classmethod
+    def generate_and_encrypt(cls, password: str, *args, **kwargs):
+        mnemonic = generate_mnemonic(*args, **kwargs)
+        return cls.encrypt_to_keystore(mnemonic, password)

xchainpy2_crypto-0.1.1/xchainpy2_crypto/tests/test_address.py

@@ -0,0 +1,50 @@
+import os
+import random
+import string
+
+import pytest
+from bip_utils import Bech32ChecksumError
+
+from xchainpy2_crypto import encode_address, decode_address
+
+
+def randomize_characters(s, n):
+    # Create a string of valid characters to choose from
+    valid_characters = string.ascii_letters + string.digits
+
+    # Convert the string to a list of characters
+    chars = list(s)
+
+    # Randomize n characters in the list
+    for _ in range(n):
+        index = random.randint(0, len(chars) - 1)
+        random_char = random.choice(valid_characters)
+        chars[index] = random_char
+
+    # Convert the list back to a string
+    randomized_string = ''.join(chars)
+
+    return randomized_string
+
+
+def test_address_encode_decode():
+    prefixes = ('thor', 'tthor', 'thorpub', 'tthorpub', 'maya', 'cacao', 'btc')
+    for i in range(100):
+        pub_key = os.urandom(32)
+        prefix = prefixes[i % len(prefixes)]
+        address = encode_address(pub_key, prefix)
+
+        assert address.startswith(prefix)
+        decoded = decode_address(address, prefix)
+        assert decoded == pub_key
+
+        other_pub_key = os.urandom(32)
+        assert decode_address(address, prefix) != other_pub_key
+
+        # noinspection PyTypeChecker
+        with pytest.raises((ValueError, Bech32ChecksumError)):
+            spoiled_address = randomize_characters(address, random.randint(2, 10))
+            decode_address(spoiled_address, prefix)
+
+        with pytest.raises(ValueError):
+            decode_address(address, randomize_characters(prefix, random.randint(5, 10)))

xchainpy2_crypto-0.1.1/xchainpy2_crypto/tests/test_keystore.py

@@ -0,0 +1,54 @@
+import os
+import random
+import tempfile
+
+import pytest
+
+from xchainpy2_crypto import generate_mnemonic, KeyStore, InvalidPasswordException
+
+
+def test_keystore_encrypt_decrypt():
+    for i in range(10):
+        mnemonic = generate_mnemonic()
+        password = os.urandom(random.randint(1, 16)).hex()
+        ks = KeyStore.encrypt_to_keystore(mnemonic, password)
+
+        mnemonic_out = ks.decrypt_from_keystore(password)
+        assert mnemonic == mnemonic_out
+
+
+def test_invalid_password():
+    mnemonic = generate_mnemonic()
+    password = 'good_password123'
+    ks = KeyStore.encrypt_to_keystore(mnemonic, password)
+
+    with pytest.raises(InvalidPasswordException):
+        ks.decrypt_from_keystore('wrong_password')
+
+
+
+def test_save_load():
+    mnemonic = generate_mnemonic()
+    password = 'good_password123'
+
+    ks = KeyStore.encrypt_to_keystore(mnemonic, password)
+
+    # save to temp file
+    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+        ks.save(temp_file.name)
+        assert os.path.exists(temp_file.name)
+
+        ks2 = KeyStore.from_file(temp_file.name)
+        assert ks.to_dict == ks2.to_dict
+        assert ks.meta == ks2.meta and bool(ks.meta)
+        assert ks.id == ks2.id and bool(ks.id)
+        assert ks.ciphertext == ks2.ciphertext and bool(ks.ciphertext)
+        assert ks.cipher == ks2.cipher and bool(ks.cipher)
+        assert ks.cipherparams_iv == ks2.cipherparams_iv and bool(ks.cipherparams_iv)
+        assert ks.kdf == ks2.kdf and bool(ks.kdf)
+        assert ks.kdfparams_prf == ks2.kdfparams_prf and bool(ks.kdfparams_prf)
+
+        assert ks.decrypt_from_keystore(password) == ks2.decrypt_from_keystore(password) == mnemonic
+
+    with pytest.raises(FileNotFoundError):
+        KeyStore.from_file('_some_non_existent.txt')

xchainpy2_crypto-0.1.1/xchainpy2_crypto/tests/test_mnemonic.py

@@ -0,0 +1,49 @@
+import pytest
+
+from xchainpy2_crypto import *
+
+
+def test_create_mnemonic():
+    mnemonic = generate_mnemonic()
+    assert len(mnemonic.split()) == 12
+    assert validate_mnemonic(mnemonic)
+
+    mnemonic = generate_mnemonic(15)
+    assert len(mnemonic.split()) == 15
+    assert validate_mnemonic(mnemonic)
+
+    mnemonic = generate_mnemonic(24)
+    assert len(mnemonic.split()) == 24
+    assert validate_mnemonic(mnemonic)
+
+    assert not validate_mnemonic('')
+    assert not validate_mnemonic(None)
+
+
+@pytest.mark.parametrize('wallet_index, key, address', [
+    (0, '437a3090352a646872f9ddc9c172e7d74d3e0472bc67ca5eccef0a64b94d791d',
+     'thor14nhwuxr8e00m2qtfgpqtwafnw25x8vmtka8c5a'),
+    (1, 'aea64d24898d02b080b6231ee0778e3f4c0b31cf756b565d586b8e7f390feafe',
+     'thor14p9fz9f8hw6f7jeh9msxg6v7xw65r52r7xnjka'),
+    (2, '55935cd344247aa0cb2dca2c13780f7ed9a571efd709cae9e82204ef57ec62ef',
+     'thor1xs3tksyfhyxe2xlwr9rtlcjm0pzthdsuavx39c')
+])
+def test_wallet_private_key_index(wallet_index, key, address):
+    # totally random, no worries
+    mnemonic = 'grain dizzy better fossil taste install tobacco bless source science category van'
+
+    derivation_path = f"44'/931'/0'/0/{wallet_index}"
+
+    seed = get_seed(mnemonic)
+    assert len(seed) == 64
+    gen_key = get_bip32(seed, derivation_path)
+
+    priv_key = get_private_key(gen_key)
+    pub_key = get_public_key(gen_key)
+
+    assert priv_key.hex() == key, 'Generated key does not match expected key'
+    assert create_address(pub_key, 'thor') == address, 'Generated address does not match expected address'
+
+    assert derive_private_key(mnemonic, derivation_path).hex() == key, 'Generated key does not match expected key'
+    assert derive_address(mnemonic, derivation_path, 'thor') == address, \
+        'Generated address does not match expected address'

xchainpy2_crypto-0.1.1/xchainpy2_crypto/utils.py

@@ -0,0 +1,129 @@
+from typing import Union
+
+from Crypto.Hash import RIPEMD160, SHA256
+from bip_utils import Bip39MnemonicGenerator, Bip39WordsNum, Bip39Languages, Bip39MnemonicValidator, \
+    Bip39SeedGenerator, Bech32Encoder, Bip32Secp256k1, Bech32Decoder
+
+
+def generate_mnemonic(words_number=Bip39WordsNum.WORDS_NUM_12, lang=Bip39Languages.ENGLISH):
+    """
+    Generate a mnemonic phrase
+    :param words_number: Words number 12/24, default: 12
+    :param lang: Language, default: English
+    :return: str: Mnemonic phrase
+    """
+    mnemonic = Bip39MnemonicGenerator(lang=lang).FromWordsNumber(words_number)
+    return str(mnemonic)
+
+
+def _normalize_mnemonic_type(mnemonic: str) -> str:
+    if isinstance(mnemonic, (list, tuple)):
+        mnemonic = ' '.join(mnemonic)
+    return mnemonic
+
+
+def validate_mnemonic(mnemonic: str, lang: str = None) -> bool:
+    """
+    :param mnemonic: Mnemonic phrase or list of words
+    :param lang: Bip39Languages or None
+    :return: bool: True if valid, False otherwise
+    """
+    if not mnemonic:
+        return False
+    mnemonic = _normalize_mnemonic_type(mnemonic)
+    return Bip39MnemonicValidator(lang).IsValid(mnemonic)
+
+
+def get_seed(mnemonic, lang: str = None) -> bytes:
+    """
+    :param mnemonic: Mnemonic phrase or list of words
+    :param lang: Bip39Languages or None
+    :return: bytes: Seed
+    """
+    mnemonic = _normalize_mnemonic_type(mnemonic)
+    return Bip39SeedGenerator(mnemonic, lang).Generate()
+
+
+def sha256ripemd160(hex_str: str) -> str:
+    """
+    Calculate `ripemd160(sha256(hex))` from the hex string
+    :param str hex_str: Input hex string
+    :return: str: Output hex string
+    """
+    data = bytes.fromhex(hex_str)
+    return RIPEMD160.RIPEMD160Hash(
+        SHA256.SHA256Hash(data).digest()
+    ).hexdigest()
+
+
+def encode_address(value: Union[str, bytes], prefix='thor') -> str:
+    """
+    Encode address from the string or bytes
+    :param str value: Input
+    :param str prefix: Address prefix 'thor' by default
+    :return: str: Address
+    """
+    if isinstance(value, str):
+        value = bytes.fromhex(value)
+    return Bech32Encoder.Encode(prefix, value)
+
+
+def decode_address(address: str, prefix: str) -> bytes:
+    """
+    Decode address to bytes
+    :param str address: Address
+    :param str prefix: Address prefix (e.g. 'thor')
+    :return: bytes: Decoded address
+    """
+    return Bech32Decoder.Decode(prefix, address)
+
+
+def create_address(public_key: bytes, prefix='thor') -> str:
+    """
+    Create address from public key
+    :param bytes public_key: Public key
+    :param str prefix: Address prefix
+    :return: str: Address
+    """
+    hexed = public_key.hex()
+    hash_hex = sha256ripemd160(hexed)
+    return encode_address(hash_hex, prefix)
+
+
+def get_bip32(seed: bytes, derivation_path: str) -> Bip32Secp256k1:
+    return Bip32Secp256k1.FromSeed(seed).DerivePath(derivation_path)
+
+
+def get_private_key(key: Bip32Secp256k1) -> bytes:
+    return key.PrivateKey().Raw().ToBytes()
+
+
+def get_public_key(key: Bip32Secp256k1) -> bytes:
+    return key.PublicKey().RawCompressed().ToBytes()
+
+
+def derive_private_key(mnemonic: str, derivation_path: str) -> bytes:
+    """
+    Derive private key from mnemonic and derivation path
+    :param str mnemonic: Mnemonic phrase or list of words
+    :param str derivation_path: Derivation path
+    :return: bytes: Private key
+    """
+    seed = get_seed(mnemonic)
+    key = get_bip32(seed, derivation_path)
+    return get_private_key(key)
+
+
+def derive_address(mnemonic: str, derivation_path: str, prefix='thor', lang: str = None) -> str:
+    """
+    Derive address from mnemonic and derivation path
+    :param str mnemonic: Mnemonic phrase or list of words
+    :param str derivation_path: Derivation path
+    :param str prefix: Address prefix
+    :param str lang: Language of mnemonic words
+    :return: str: Address
+    """
+    seed = get_seed(mnemonic, lang)
+    key = get_bip32(seed, derivation_path)
+    public_key = get_public_key(key)
+    return create_address(public_key, prefix)

xchainpy2_crypto-0.1.1/xchainpy2_crypto.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: xchainpy2_crypto
+Version: 0.1.1
+Summary: XChainPy2 Crypto utils and keystore management
+Author-email: Tirinox <tirinox@gmail.com>
+License: MIT
+Project-URL: source, https://github.com/tirinox/xchainpy
+Keywords: Crypto,THORChain,Blockchain,XChain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bip-utils<3.0.0,>=2.12.1.0
+Requires-Dist: pycryptodome<4.0,>=3.23
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# How it works
+Typically keystore files encrypt a seed to a file, however this is not appropriate or UX friendly, since the phrase
+cannot be recovered after the fact.
+
+Crypto design:
+
+`[entropy] -> [phrase] -> [seed] -> [privateKey] -> [publicKey] -> [address]`
+
+Instead, XCHAIN-CRYPTO stores the phrase in a keystore file, then decrypts and passes this phrase to other clients:
+
+`[keystore] -> XCHAIN-CRYPTO -> [phrase] -> ChainClient`
+
+The ChainClients can then convert this into their respective key-pairs and addresses. Users can also export their
+phrases after the fact, ensuring they have saved it securely. This could enhance UX onboarding since users aren't forced
+to write their phrases down immediately for empty or test wallets.
+
+### Documentation
+
+👉 https://xchainpy2.readthedocs.io/en/latest/packages/xchainpy2_crypto.html

xchainpy2_crypto-0.1.1/xchainpy2_crypto.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+xchainpy2_crypto/__init__.py
+xchainpy2_crypto/keystore.py
+xchainpy2_crypto/utils.py
+xchainpy2_crypto.egg-info/PKG-INFO
+xchainpy2_crypto.egg-info/SOURCES.txt
+xchainpy2_crypto.egg-info/dependency_links.txt
+xchainpy2_crypto.egg-info/requires.txt
+xchainpy2_crypto.egg-info/top_level.txt
+xchainpy2_crypto/tests/__init__.py
+xchainpy2_crypto/tests/test_address.py
+xchainpy2_crypto/tests/test_keystore.py
+xchainpy2_crypto/tests/test_mnemonic.py

xchainpy2_crypto-0.1.1/xchainpy2_crypto.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xchainpy2_crypto-0.1.1/xchainpy2_crypto.egg-info/requires.txt

@@ -0,0 +1,5 @@
+bip-utils<3.0.0,>=2.12.1.0
+pycryptodome<4.0,>=3.23
+
+[test]
+pytest

xchainpy2_crypto-0.1.1/xchainpy2_crypto.egg-info/top_level.txt

@@ -0,0 +1 @@
+xchainpy2_crypto