token-network 0.1.0__tar.gz

token_network-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: token-network
+Version: 0.1.0
+Summary: Validate input and return token network config (e.g. network.bitcoin, network.bsc.usdt)
+License: MIT
+Keywords: blockchain,tokens,networks,crypto,config
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: requires-python
+
+# token-network
+
+Python library that validates input and returns token network config. Use attribute access like `network.bitcoin` or `network.bsc.usdt` to get network and token data.
+
+## Install
+
+From PyPI (after publishing):
+
+```bash
+pip install token-network
+```
+
+From source (development):
+
+```bash
+pip install -e .
+```
+
+## Publishing to PyPI (so others can `pip install token-network`)
+
+1. Create an account on [pypi.org](https://pypi.org) (and optionally [test.pypi.org](https://test.pypi.org) for testing).
+
+2. Install build and twine:
+   ```bash
+   pip install build twine
+   ```
+
+3. Build the package:
+   ```bash
+   cd /path/to/token-network
+   python -m build
+   ```
+
+4. Upload to PyPI (you’ll be prompted for your PyPI username and password or token):
+   ```bash
+   twine upload dist/*
+   ```
+   To try Test PyPI first: `twine upload --repository testpypi dist/*`, then install with:
+   `pip install --index-url https://test.pypi.org/simple/ token-network`
+
+5. After that, anyone can run:
+   ```bash
+   pip install token-network
+   ```
+
+## Usage
+
+```python
+from token_network import network, TokenNetworkError
+```
+
+### Get all config for a network
+
+```python
+# Network config only
+network.bitcoin.config
+# {'network_type': 'UTXO', 'token_standard': 'BTC', 'base_token': 'BTC', ...}
+
+# Tokens on that network (with contract_address, decimal, native, token_info)
+network.bitcoin.tokens
+
+# Full payload: config + tokens
+network.bitcoin.to_dict()
+# {"config": {...}, "tokens": [...]}
+```
+
+### Get data for a token on a network
+
+```python
+# All data for USDT on BSC: network config, token info, contract_address, decimal, native
+network.bsc.usdt
+# {
+#   'network': {...},
+#   'token': {'slug': 'usdt', 'symbol': 'USDT', 'name': 'tether', ...},
+#   'contract_address': '0x55d398326f99059fF775485246999027B3197955',
+#   'decimal': 18,
+#   'native': False
+# }
+
+network.ethereum.usdt
+network.tron.usdt
+```
+
+### Validation
+
+Unknown network or token raises `TokenNetworkError`:
+
+```python
+try:
+    network.unknown_chain
+except TokenNetworkError as e:
+    print(e)  # Unknown network: 'unknown_chain'. Known networks: bitcoin, bsc, ...
+
+try:
+    network.bsc.unknown_token
+except TokenNetworkError as e:
+    print(e)  # Token 'UNKNOWN_TOKEN' is not defined on network 'bsc'. Available tokens: [...]
+```
+
+## Data sources
+
+Config is loaded from YAML inside the package:
+
+- `networks.yaml` — chain config (network_type, token_standard, base_token, confirmation_number, …)
+- `tokens.yaml` — token definitions (symbol, name, precision, factor)
+- `token_networks.yaml` — which token exists on which network (contract_address, decimal, native)
+
+To change data, edit the YAML files in `token_network/data/` (or the repo root and sync into the package).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

token_network-0.1.0/README.md

@@ -0,0 +1,115 @@
+# token-network
+
+Python library that validates input and returns token network config. Use attribute access like `network.bitcoin` or `network.bsc.usdt` to get network and token data.
+
+## Install
+
+From PyPI (after publishing):
+
+```bash
+pip install token-network
+```
+
+From source (development):
+
+```bash
+pip install -e .
+```
+
+## Publishing to PyPI (so others can `pip install token-network`)
+
+1. Create an account on [pypi.org](https://pypi.org) (and optionally [test.pypi.org](https://test.pypi.org) for testing).
+
+2. Install build and twine:
+   ```bash
+   pip install build twine
+   ```
+
+3. Build the package:
+   ```bash
+   cd /path/to/token-network
+   python -m build
+   ```
+
+4. Upload to PyPI (you’ll be prompted for your PyPI username and password or token):
+   ```bash
+   twine upload dist/*
+   ```
+   To try Test PyPI first: `twine upload --repository testpypi dist/*`, then install with:
+   `pip install --index-url https://test.pypi.org/simple/ token-network`
+
+5. After that, anyone can run:
+   ```bash
+   pip install token-network
+   ```
+
+## Usage
+
+```python
+from token_network import network, TokenNetworkError
+```
+
+### Get all config for a network
+
+```python
+# Network config only
+network.bitcoin.config
+# {'network_type': 'UTXO', 'token_standard': 'BTC', 'base_token': 'BTC', ...}
+
+# Tokens on that network (with contract_address, decimal, native, token_info)
+network.bitcoin.tokens
+
+# Full payload: config + tokens
+network.bitcoin.to_dict()
+# {"config": {...}, "tokens": [...]}
+```
+
+### Get data for a token on a network
+
+```python
+# All data for USDT on BSC: network config, token info, contract_address, decimal, native
+network.bsc.usdt
+# {
+#   'network': {...},
+#   'token': {'slug': 'usdt', 'symbol': 'USDT', 'name': 'tether', ...},
+#   'contract_address': '0x55d398326f99059fF775485246999027B3197955',
+#   'decimal': 18,
+#   'native': False
+# }
+
+network.ethereum.usdt
+network.tron.usdt
+```
+
+### Validation
+
+Unknown network or token raises `TokenNetworkError`:
+
+```python
+try:
+    network.unknown_chain
+except TokenNetworkError as e:
+    print(e)  # Unknown network: 'unknown_chain'. Known networks: bitcoin, bsc, ...
+
+try:
+    network.bsc.unknown_token
+except TokenNetworkError as e:
+    print(e)  # Token 'UNKNOWN_TOKEN' is not defined on network 'bsc'. Available tokens: [...]
+```
+
+## Data sources
+
+Config is loaded from YAML inside the package:
+
+- `networks.yaml` — chain config (network_type, token_standard, base_token, confirmation_number, …)
+- `tokens.yaml` — token definitions (symbol, name, precision, factor)
+- `token_networks.yaml` — which token exists on which network (contract_address, decimal, native)
+
+To change data, edit the YAML files in `token_network/data/` (or the repo root and sync into the package).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

token_network-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "token-network"
+version = "0.1.0"
+description = "Validate input and return token network config (e.g. network.bitcoin, network.bsc.usdt)"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = []
+keywords = ["blockchain", "tokens", "networks", "crypto", "config"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "PyYAML>=6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["token_network*"]
+
+[tool.setuptools.package-dir]
+"" = "."
+
+[tool.setuptools.package-data]
+token_network = ["data/*.yaml"]

token_network-0.1.0/setup.cfg

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

token_network-0.1.0/setup.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from setuptools import setup, find_packages
+
+_readme = Path(__file__).parent / "README.md"
+long_description = _readme.read_text(encoding="utf-8") if _readme.exists() else ""
+
+setup(
+    name="token-network",
+    version="0.1.0",
+    description="Validate input and return token network config (e.g. network.bitcoin, network.bsc.usdt)",
+    long_description=long_description or None,
+    long_description_content_type="text/markdown" if long_description else None,
+    packages=find_packages(where=".", include=["token_network*"]),
+    package_dir={"": "."},
+    package_data={"token_network": ["data/*.yaml"]},
+    python_requires=">=3.8",
+    install_requires=[
+        "PyYAML>=6.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0",
+        ],
+    },
+    keywords=["blockchain", "tokens", "networks", "crypto", "config"],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)

token_network-0.1.0/tests/test_network.py

@@ -0,0 +1,60 @@
+"""Tests for token_network package."""
+
+import pytest
+from token_network import network, TokenNetworkError
+
+
+def test_network_bitcoin_returns_config():
+    cfg = network.bitcoin.config
+    assert cfg["network_type"] == "UTXO"
+    assert cfg["base_token"] == "BTC"
+    assert cfg["base_token_decimal"] == 8
+
+
+def test_network_bitcoin_tokens():
+    tokens = network.bitcoin.tokens
+    assert len(tokens) >= 1
+    btc = next(t for t in tokens if t["token"] == "BTC")
+    assert btc["native"] is True
+    assert btc["decimal"] == 8
+    assert btc["token_info"]["symbol"] == "BTC"
+
+
+def test_network_bitcoin_to_dict():
+    data = network.bitcoin.to_dict()
+    assert "config" in data
+    assert "tokens" in data
+    assert data["config"]["base_token"] == "BTC"
+
+
+def test_network_bsc_usdt():
+    data = network.bsc.usdt
+    assert data["network"]["network_type"] == "EVM"
+    assert data["token"]["symbol"] == "USDT"
+    assert data["contract_address"] == "0x55d398326f99059fF775485246999027B3197955"
+    assert data["decimal"] == 18
+    assert data["native"] is False
+
+
+def test_unknown_network_raises():
+    with pytest.raises(TokenNetworkError) as exc_info:
+        _ = network.nonexistent_chain
+    assert "Unknown network" in str(exc_info.value)
+    assert "nonexistent_chain" in str(exc_info.value)
+
+
+def test_unknown_token_on_network_raises():
+    with pytest.raises(TokenNetworkError) as exc_info:
+        _ = network.bsc.nonexistent_token
+    assert "not defined on network" in str(exc_info.value)
+    assert "bsc" in str(exc_info.value)
+
+
+def test_case_insensitive_network():
+    assert network.BSC.config == network.bsc.config
+    assert network.Bitcoin.config == network.bitcoin.config
+
+
+def test_case_insensitive_token():
+    assert network.bsc.USDT == network.bsc.usdt
+    assert network.ethereum.Usdt["token"]["symbol"] == "USDT"

token_network-0.1.0/token_network/__init__.py

@@ -0,0 +1,23 @@
+"""
+token_network: validate input and return token network config.
+
+Usage:
+    from token_network import network
+
+    # All config for a network (config + tokens on that network)
+    network.bitcoin.config
+    network.bitcoin.tokens
+    network.bitcoin.to_dict()   # {"config": {...}, "tokens": [...]}
+
+    # Data for a specific token on a network
+    network.bsc.usdt   # dict: network config, token info, contract_address, decimal, native
+    network.ethereum.usdt
+    network.tron.usdt
+
+Unknown network or token raises token_network.TokenNetworkError.
+"""
+
+from ._accessor import TokenNetworkError, NetworkAccessor, network
+
+__all__ = ["network", "TokenNetworkError", "NetworkAccessor"]
+__version__ = "0.1.0"

token_network-0.1.0/token_network/_accessor.py

@@ -0,0 +1,92 @@
+"""Attribute-based access to network and token config: network.bitcoin, network.bsc.usdt."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._loader import load_all
+
+
+class TokenNetworkError(Exception):
+    """Raised when a network or token is unknown or invalid."""
+
+
+class _NetworkNode:
+    """Represents one network. Supports .config, .tokens, and .<token_symbol> (e.g. .usdt)."""
+
+    __slots__ = ("_net_key", "_network_tokens", "_token_on_network")
+
+    def __init__(
+        self,
+        net_key: str,
+        network_tokens: dict[str, dict[str, Any]],
+        token_on_network: dict[tuple[str, str], dict[str, Any]],
+    ) -> None:
+        self._net_key = net_key
+        self._network_tokens = network_tokens
+        self._token_on_network = token_on_network
+
+    @property
+    def config(self) -> dict[str, Any]:
+        """Network config for this network."""
+        if self._net_key not in self._network_tokens:
+            raise TokenNetworkError(f"Unknown network: {self._net_key!r}")
+        return dict(self._network_tokens[self._net_key]["config"])
+
+    @property
+    def tokens(self) -> list[dict[str, Any]]:
+        """List of token bindings on this network (each with token_info, contract_address, etc.)."""
+        if self._net_key not in self._network_tokens:
+            raise TokenNetworkError(f"Unknown network: {self._net_key!r}")
+        return list(self._network_tokens[self._net_key]["tokens"])
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        token_sym = name.upper()
+        key = (self._net_key, token_sym)
+        if key not in self._token_on_network:
+            raise TokenNetworkError(
+                f"Token {token_sym!r} is not defined on network {self._net_key!r}. "
+                f"Available tokens: {[t['token'] for t in self.tokens]}"
+            )
+        return dict(self._token_on_network[key])
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return full network data: config and tokens (e.g. 'all bitcoin config')."""
+        return {"config": self.config, "tokens": self.tokens}
+
+
+class NetworkAccessor:
+    """
+    Attribute-based access to token network config.
+    - network.bitcoin  -> network node (use .config, .tokens, or .to_dict() for full config)
+    - network.bsc.usdt -> dict with network config, token info, contract_address, decimal, native
+    """
+
+    __slots__ = ("_network_tokens", "_token_on_network")
+
+    def __init__(self) -> None:
+        self._network_tokens, self._token_on_network, _ = load_all()
+
+    def __getattr__(self, name: str) -> _NetworkNode:
+        if name.startswith("_"):
+            raise AttributeError(name)
+        net_key = name.lower()
+        if net_key not in self._network_tokens:
+            known = ", ".join(sorted(self._network_tokens.keys()))
+            raise TokenNetworkError(
+                f"Unknown network: {name!r}. Known networks: {known}"
+            )
+        return _NetworkNode(
+            net_key,
+            self._network_tokens,
+            self._token_on_network,
+        )
+
+    def __dir__(self) -> list[str]:
+        return sorted(self._network_tokens.keys())
+
+
+# Singleton used as `network`
+network = NetworkAccessor()

token_network-0.1.0/token_network/_loader.py

@@ -0,0 +1,185 @@
+"""Load and validate networks, tokens, and token_networks from YAML."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+# Package data path: support both installed package and development layout
+def _data_dir() -> Path:
+    if getattr(sys, "frozen", False):
+        return Path(sys._MEIPASS) / "token_network" / "data"
+    here = Path(__file__).resolve().parent
+    return here / "data"
+
+
+def _load_yaml(name: str) -> dict[str, Any]:
+    path = _data_dir() / name
+    if not path.exists():
+        raise FileNotFoundError(f"Config file not found: {path}")
+    with open(path, encoding="utf-8") as f:
+        return yaml.safe_load(f) or {}
+
+
+def load_networks() -> dict[str, dict[str, Any]]:
+    data = _load_yaml("networks.yaml")
+    networks = data.get("networks") or {}
+    if not isinstance(networks, dict):
+        raise ValueError("networks.yaml: 'networks' must be a mapping")
+    return {k.lower(): dict(v) for k, v in networks.items()}
+
+
+def load_tokens() -> dict[str, dict[str, Any]]:
+    data = _load_yaml("tokens.yaml")
+    tokens_list = data.get("tokens") or []
+    if not isinstance(tokens_list, list):
+        raise ValueError("tokens.yaml: 'tokens' must be a list")
+    by_symbol: dict[str, dict[str, Any]] = {}
+    for t in tokens_list:
+        sym = (t.get("symbol") or "").strip().upper()
+        if not sym:
+            continue
+        by_symbol[sym] = dict(t)
+    return by_symbol
+
+
+# Wise standard: NetworkSymbolType (wise_market) uses COIN / TOKEN
+TYPE_COIN = "COIN"
+TYPE_TOKEN = "TOKEN"
+
+
+def load_token_networks() -> list[dict[str, Any]]:
+    data = _load_yaml("token_networks.yaml")
+    tn = data.get("token_networks") or []
+    if not isinstance(tn, list):
+        raise ValueError("token_networks.yaml: 'token_networks' must be a list")
+    return [dict(entry) for entry in tn]
+
+
+def _normalize_token_network_entry(
+    entry: dict[str, Any],
+    tokens: dict[str, dict[str, Any]],
+    slug_to_symbol: dict[str, str],
+) -> dict[str, Any] | None:
+    """
+    Normalize a token_network entry to wise standard (network_slug, symbol_slug, decimals, type).
+    Accepts both legacy (network, token, decimal, native) and wise (network_slug, symbol_slug, decimals, type).
+    """
+    net_key = (entry.get("network_slug") or entry.get("network") or "").strip().lower()
+    symbol_slug = (entry.get("symbol_slug") or "").strip().lower()
+    token_sym = (entry.get("token") or "").strip().upper()
+    if symbol_slug and not token_sym:
+        token_sym = slug_to_symbol.get(symbol_slug, "").upper()
+    if not net_key or not token_sym:
+        return None
+    if token_sym not in tokens:
+        return None
+
+    decimals = entry.get("decimals") if entry.get("decimals") is not None else entry.get("decimal")
+    type_raw = (entry.get("type") or "").strip().upper()
+    if type_raw in (TYPE_COIN, TYPE_TOKEN):
+        native = type_raw == TYPE_COIN
+        type_val = type_raw
+    else:
+        native = bool(entry.get("native", True))
+        type_val = TYPE_COIN if native else TYPE_TOKEN
+
+    return {
+        "network": net_key,
+        "network_slug": net_key,
+        "token": token_sym,
+        "symbol_slug": tokens[token_sym].get("slug", "").lower(),
+        "contract_address": entry.get("contract_address"),
+        "decimal": decimals,
+        "decimals": decimals,
+        "native": native,
+        "type": type_val,
+    }
+
+
+def build_index(
+    networks: dict[str, dict[str, Any]],
+    tokens: dict[str, dict[str, Any]],
+    token_networks: list[dict[str, Any]],
+) -> tuple[
+    dict[str, dict[str, Any]],
+    dict[tuple[str, str], dict[str, Any]],
+]:
+    """
+    Build indexes:
+    - network_tokens: network_id -> { "config": network_config, "tokens": [token_network_entries] }
+    - token_on_network: (network_id, token_symbol) -> merged token_network + token + network
+    Supports wise standard: network_slug, symbol_slug, decimals, type (COIN/TOKEN).
+    """
+    slug_to_symbol = {
+        (v.get("slug") or "").strip().lower(): k
+        for k, v in tokens.items()
+        if (v.get("slug") or "").strip()
+    }
+    network_tokens: dict[str, dict[str, Any]] = {}
+    token_on_network: dict[tuple[str, str], dict[str, Any]] = {}
+
+    for entry in token_networks:
+        normalized = _normalize_token_network_entry(entry, tokens, slug_to_symbol)
+        if normalized is None:
+            continue
+        net_key = normalized["network"]
+        if net_key not in networks:
+            continue
+
+        token_sym = normalized["token"]
+        net_config = networks[net_key]
+        token_info = tokens[token_sym]
+        binding = {
+            "network": net_key,
+            "network_slug": net_key,
+            "token": token_sym,
+            "symbol_slug": normalized["symbol_slug"],
+            "contract_address": normalized["contract_address"],
+            "decimal": normalized["decimal"],
+            "decimals": normalized["decimals"],
+            "native": normalized["native"],
+            "type": normalized["type"],
+        }
+
+        if net_key not in network_tokens:
+            network_tokens[net_key] = {"config": net_config, "tokens": []}
+        network_tokens[net_key]["tokens"].append({
+            **binding,
+            "token_info": token_info,
+        })
+
+        key = (net_key, token_sym)
+        token_on_network[key] = {
+            "network": net_config,
+            "token": token_info,
+            "contract_address": binding["contract_address"],
+            "decimal": binding["decimal"],
+            "decimals": binding["decimals"],
+            "native": binding["native"],
+            "type": binding["type"],
+        }
+
+    # Ensure every network from networks.yaml appears (even if no tokens listed)
+    for net_key, net_config in networks.items():
+        if net_key not in network_tokens:
+            network_tokens[net_key] = {"config": net_config, "tokens": []}
+
+    return network_tokens, token_on_network
+
+
+def load_all() -> tuple[
+    dict[str, dict[str, Any]],
+    dict[str, dict[str, Any]],
+    dict[tuple[str, str], dict[str, Any]],
+]:
+    """Load YAMLs and return (network_tokens, token_on_network, networks_only)."""
+    networks = load_networks()
+    tokens = load_tokens()
+    token_networks = load_token_networks()
+    network_tokens, token_on_network = build_index(networks, tokens, token_networks)
+    networks_only = {k: v["config"] for k, v in network_tokens.items()}
+    return network_tokens, token_on_network, networks_only

token_network-0.1.0/token_network/data/networks.yaml

@@ -0,0 +1,89 @@
+# Blockchain network configuration (wise standard: slug = key, name = display name).
+# Consumed by network-manager via NETWORK_CONFIG_FILE (expects this file to have a top-level "networks" key).
+# Schema matches config.network_config_loader.NetworkConfig.
+
+networks:
+  ethereum:
+    slug: ethereum
+    name: Ethereum
+    network_type: EVM
+    token_standard: ERC20
+    base_token: ETH
+    base_token_decimal: 18
+    confirmation_number: 10
+    confirmation_check_time: 2
+    resource_providing_amount: 0.0005
+    resource_providing_below_threshold: 0.0001
+    is_tag_based: false
+  bsc:
+    slug: bsc
+    name: BNB Smart Chain
+    network_type: EVM
+    token_standard: ERC20  # BEP20
+    base_token: BNB
+    base_token_decimal: 18
+    confirmation_number: 10
+    confirmation_check_time: 1
+    resource_providing_amount: 0.0005
+    resource_providing_below_threshold: 0.0001
+    is_tag_based: false
+  tron:
+    slug: tron
+    name: Tron
+    network_type: TVM
+    token_standard: TRC20
+    base_token: TRX
+    base_token_decimal: 6
+    confirmation_number: 20
+    confirmation_check_time: 1
+    resource_providing_amount: 10
+    resource_providing_below_threshold: 7
+    is_tag_based: false
+  solana:
+    slug: solana
+    name: Solana
+    network_type: SOLANA
+    token_standard: SPL
+    base_token: SOL
+    base_token_decimal: 9
+    confirmation_number: 5
+    confirmation_check_time: 1
+    resource_providing_amount: 0.0005
+    resource_providing_below_threshold: 0.0005
+    is_tag_based: false
+  bitcoin:
+    slug: bitcoin
+    name: Bitcoin
+    network_type: UTXO
+    token_standard: BTC
+    base_token: BTC
+    base_token_decimal: 8
+    confirmation_number: 2
+    confirmation_check_time: 2
+    resource_providing_amount: 0
+    resource_providing_below_threshold: 0
+    is_tag_based: false
+  ripple:
+    slug: ripple
+    name: XRP Ledger
+    network_type: XRPL
+    token_standard: XRP
+    base_token: XRP
+    base_token_decimal: 6
+    confirmation_number: 1
+    confirmation_check_time: 1
+    resource_providing_amount: 0
+    resource_providing_below_threshold: 0
+    is_tag_based: true
+  dogecoin:
+    slug: dogecoin
+    name: Dogecoin
+    network_type: UTXO
+    token_standard: DOGE
+    base_token: DOGE
+    base_token_decimal: 8
+    confirmation_number: 6
+    confirmation_check_time: 5
+    resource_providing_amount: 0
+    resource_providing_below_threshold: 0
+    is_tag_based: false

token_network-0.1.0/token_network/data/token_networks.yaml

@@ -0,0 +1,97 @@
+# Token–network bindings (wise standard): network_slug, symbol_slug, decimals, type (COIN/TOKEN).
+# References: network_slug = key in networks.yaml; symbol_slug = slug in tokens.yaml.
+# type: COIN = native, TOKEN = non-native. Sorted by network_slug.
+
+token_networks:
+  # bitcoin
+  - network_slug: bitcoin
+    symbol_slug: btc
+    contract_address: null
+    decimals: 8
+    type: COIN
+  # bsc
+  - network_slug: bsc
+    symbol_slug: bnb
+    contract_address: null
+    decimals: 18
+    type: COIN
+  - network_slug: bsc
+    symbol_slug: usdc
+    contract_address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"
+    decimals: 18
+    type: TOKEN
+  - network_slug: bsc
+    symbol_slug: usdt
+    contract_address: "0x55d398326f99059fF775485246999027B3197955"
+    decimals: 18
+    type: TOKEN
+  - network_slug: bsc
+    symbol_slug: btc
+    contract_address: "0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c"
+    decimals: 18
+    type: TOKEN
+  # dogecoin
+  - network_slug: dogecoin
+    symbol_slug: doge
+    contract_address: null
+    decimals: 8
+    type: COIN
+  # ethereum
+  - network_slug: ethereum
+    symbol_slug: eth
+    contract_address: null
+    decimals: 18
+    type: COIN
+  - network_slug: ethereum
+    symbol_slug: usdc
+    contract_address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+    decimals: 6
+    type: TOKEN
+  - network_slug: ethereum
+    symbol_slug: usdt
+    contract_address: "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+    decimals: 6
+    type: TOKEN
+  - network_slug: ethereum
+    symbol_slug: shib
+    contract_address: "0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE"
+    decimals: 18
+    type: TOKEN
+  - network_slug: ethereum
+    symbol_slug: link
+    contract_address: "0x514910771AF9Ca656af840dff83E8264EcF986CA"
+    decimals: 18
+    type: TOKEN
+  - network_slug: ethereum
+    symbol_slug: aave
+    contract_address: "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9"
+    decimals: 18
+    type: TOKEN
+  - network_slug: ethereum
+    symbol_slug: uni
+    contract_address: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984"
+    decimals: 18
+    type: TOKEN
+  # ripple
+  - network_slug: ripple
+    symbol_slug: xrp
+    contract_address: null
+    decimals: 6
+    type: COIN
+  # solana
+  - network_slug: solana
+    symbol_slug: sol
+    contract_address: null
+    decimals: 9
+    type: COIN
+  # tron
+  - network_slug: tron
+    symbol_slug: trx
+    contract_address: null
+    decimals: 6
+    type: COIN
+  - network_slug: tron
+    symbol_slug: usdt
+    contract_address: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
+    decimals: 6
+    type: TOKEN

token_network-0.1.0/token_network/data/tokens.yaml

@@ -0,0 +1,82 @@
+# Token definitions: slug, symbol, standard_symbol, name, precision, factor.
+# Reference tokens in token_networks.yaml by symbol (e.g. ETH, USDT).
+
+tokens:
+  - slug: sol
+    symbol: SOL
+    standard_symbol: SOL
+    name: solana
+    precision: 9
+    factor: 1e9
+  - slug: usdt
+    symbol: USDT
+    standard_symbol: USDT
+    name: tether
+    precision: 6
+    factor: 1e6
+  - slug: aave
+    symbol: AAVE
+    standard_symbol: AAVE
+    name: Aave
+    precision: 18
+    factor: 1e18
+  - slug: doge
+    symbol: DOGE
+    standard_symbol: DOGE
+    name: doge
+    precision: 8
+    factor: 1e8
+  - slug: shib
+    symbol: SHIB
+    standard_symbol: SHIB
+    name: SHIBA INU
+    precision: 18
+    factor: 1e18
+  - slug: link
+    symbol: LINK
+    standard_symbol: LINK
+    name: Chainlink
+    precision: 18
+    factor: 1e18
+  - slug: xrp
+    symbol: XRP
+    standard_symbol: XRP
+    name: ripple
+    precision: 6
+    factor: 1e6
+  - slug: btc
+    symbol: BTC
+    standard_symbol: BTC
+    name: Bitcoin
+    precision: 8
+    factor: 1e8
+  - slug: eth
+    symbol: ETH
+    standard_symbol: ETH
+    name: ethereum
+    precision: 18
+    factor: 1e18
+  - slug: trx
+    symbol: TRX
+    standard_symbol: TRX
+    name: Tron
+    precision: 6
+    factor: 1e6
+  - slug: usdc
+    symbol: USDC
+    standard_symbol: USDC
+    name: USD Coin
+    precision: 6
+    factor: 1e6
+  - slug: bnb
+    symbol: BNB
+    standard_symbol: BNB
+    name: Binance Coin
+    precision: 18
+    factor: 1e18
+  - slug: uni
+    symbol: UNI
+    standard_symbol: UNI
+    name: Uniswap
+    precision: 18
+    factor: 1e18

token_network-0.1.0/token_network.egg-info/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: token-network
+Version: 0.1.0
+Summary: Validate input and return token network config (e.g. network.bitcoin, network.bsc.usdt)
+License: MIT
+Keywords: blockchain,tokens,networks,crypto,config
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: requires-python
+
+# token-network
+
+Python library that validates input and returns token network config. Use attribute access like `network.bitcoin` or `network.bsc.usdt` to get network and token data.
+
+## Install
+
+From PyPI (after publishing):
+
+```bash
+pip install token-network
+```
+
+From source (development):
+
+```bash
+pip install -e .
+```
+
+## Publishing to PyPI (so others can `pip install token-network`)
+
+1. Create an account on [pypi.org](https://pypi.org) (and optionally [test.pypi.org](https://test.pypi.org) for testing).
+
+2. Install build and twine:
+   ```bash
+   pip install build twine
+   ```
+
+3. Build the package:
+   ```bash
+   cd /path/to/token-network
+   python -m build
+   ```
+
+4. Upload to PyPI (you’ll be prompted for your PyPI username and password or token):
+   ```bash
+   twine upload dist/*
+   ```
+   To try Test PyPI first: `twine upload --repository testpypi dist/*`, then install with:
+   `pip install --index-url https://test.pypi.org/simple/ token-network`
+
+5. After that, anyone can run:
+   ```bash
+   pip install token-network
+   ```
+
+## Usage
+
+```python
+from token_network import network, TokenNetworkError
+```
+
+### Get all config for a network
+
+```python
+# Network config only
+network.bitcoin.config
+# {'network_type': 'UTXO', 'token_standard': 'BTC', 'base_token': 'BTC', ...}
+
+# Tokens on that network (with contract_address, decimal, native, token_info)
+network.bitcoin.tokens
+
+# Full payload: config + tokens
+network.bitcoin.to_dict()
+# {"config": {...}, "tokens": [...]}
+```
+
+### Get data for a token on a network
+
+```python
+# All data for USDT on BSC: network config, token info, contract_address, decimal, native
+network.bsc.usdt
+# {
+#   'network': {...},
+#   'token': {'slug': 'usdt', 'symbol': 'USDT', 'name': 'tether', ...},
+#   'contract_address': '0x55d398326f99059fF775485246999027B3197955',
+#   'decimal': 18,
+#   'native': False
+# }
+
+network.ethereum.usdt
+network.tron.usdt
+```
+
+### Validation
+
+Unknown network or token raises `TokenNetworkError`:
+
+```python
+try:
+    network.unknown_chain
+except TokenNetworkError as e:
+    print(e)  # Unknown network: 'unknown_chain'. Known networks: bitcoin, bsc, ...
+
+try:
+    network.bsc.unknown_token
+except TokenNetworkError as e:
+    print(e)  # Token 'UNKNOWN_TOKEN' is not defined on network 'bsc'. Available tokens: [...]
+```
+
+## Data sources
+
+Config is loaded from YAML inside the package:
+
+- `networks.yaml` — chain config (network_type, token_standard, base_token, confirmation_number, …)
+- `tokens.yaml` — token definitions (symbol, name, precision, factor)
+- `token_networks.yaml` — which token exists on which network (contract_address, decimal, native)
+
+To change data, edit the YAML files in `token_network/data/` (or the repo root and sync into the package).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```

token_network-0.1.0/token_network.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+setup.py
+./token_network/__init__.py
+./token_network/_accessor.py
+./token_network/_loader.py
+./token_network/data/networks.yaml
+./token_network/data/token_networks.yaml
+./token_network/data/tokens.yaml
+tests/test_network.py
+token_network/__init__.py
+token_network/_accessor.py
+token_network/_loader.py
+token_network.egg-info/PKG-INFO
+token_network.egg-info/SOURCES.txt
+token_network.egg-info/dependency_links.txt
+token_network.egg-info/requires.txt
+token_network.egg-info/top_level.txt
+token_network/data/networks.yaml
+token_network/data/token_networks.yaml
+token_network/data/tokens.yaml

token_network-0.1.0/token_network.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

token_network-0.1.0/token_network.egg-info/requires.txt

@@ -0,0 +1,4 @@
+PyYAML>=6.0
+
+[dev]
+pytest>=7.0

token_network-0.1.0/token_network.egg-info/top_level.txt

@@ -0,0 +1 @@
+token_network