axis-synome 0.1.0.dev66__tar.gz → 0.1.0.dev68__tar.gz

{axis_synome-0.1.0.dev66/src/axis_synome.egg-info → axis_synome-0.1.0.dev68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axis-synome
-Version: 0.1.0.dev66
+Version: 0.1.0.dev68
 Summary: Axis specification modules (entities, formulas, validators)
 Author-email: Archon Tech <hello@archontech.ai>
 License: MIT

{axis_synome-0.1.0.dev66 → axis_synome-0.1.0.dev68}/src/axis_synome/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.0.dev66'
-__version_tuple__ = version_tuple = (0, 1, 0, 'dev66')
+__version__ = version = '0.1.0.dev68'
+__version_tuple__ = version_tuple = (0, 1, 0, 'dev68')
 
 __commit_id__ = commit_id = None

axis_synome-0.1.0.dev68/src/axis_synome/export_entities.py

@@ -0,0 +1,397 @@
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from axis_synome.spec.asc.entities.alm_proxies import (
+    STL_ADDITIONAL_PROXIES,
+    AlmProxy,
+)
+from axis_synome.spec.asc.entities.assets_by_prime import ASSETS_BY_PRIME, PrimeName
+from axis_synome.spec.asc.entities.assets_missing_from_atlas import (
+    MISSING_FROM_ATLAS_BY_PRIME,
+)
+from axis_synome.spec.asc.entities.networks import STL_CHAIN_BY_NETWORK
+from axis_synome.spec.asc.entities.protocol_sets import (
+    ATOKEN_PROTOCOLS,
+    ERC4626_PROTOCOLS,
+    L1_PSM_PROTOCOLS,
+    L2_PSM_PROTOCOLS,
+    UNISWAP_STYLE_PROTOCOLS,
+    Protocol,
+)
+
+# Proxy roles. "alm" is the canonical ALM Proxy holding operational allocation
+# positions; "subproxy" is an additional SubProxy/treasury wallet tracked for the
+# same (star, chain).
+PROXY_ROLE_ALM = "alm"
+PROXY_ROLE_SUBPROXY = "subproxy"
+
+
+class ProxyEntry(BaseModel):
+    """A single ALM-controlled wallet exported for a (star, chain).
+
+    More than one may exist per (star, chain): the canonical ALM Proxy plus any
+    additional SubProxy/treasury wallets. ``role`` lets consumers tell them apart
+    without relying on list position.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    star: str
+    chain: str
+    address: str
+    role: str
+
+
+class TokenEntryModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    contract_address: str
+    wallet_address: str
+    asset_address: str | None
+    star: str
+    chain: str
+    protocol: str
+    allocation_type: str
+    token_type: str
+
+
+class AssetsByPrimeContainer(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    # star -> list of token entries.
+    entries: dict[str, list[TokenEntryModel]] = Field(serialization_alias="ASSETS_BY_PRIME")
+
+
+class AlmProxiesContainer(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    # star -> chain -> list of proxies.
+    proxies: dict[str, dict[str, list[ProxyEntry]]] = Field(serialization_alias="AlmProxy")
+
+
+class EntitiesModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    assets_by_prime: AssetsByPrimeContainer
+    alm_proxies: AlmProxiesContainer
+
+
+class AscModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    entities: EntitiesModel
+
+
+class SpecModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    asc: AscModel
+
+
+class AxisSynomeModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    spec: SpecModel
+
+
+class AxisSynomeContract(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    version: str
+    axis_synome_git_commit: str
+    axis_synome: AxisSynomeModel
+
+
+def _slug(text: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+
+
+def _prime_to_star(prime: PrimeName | str) -> str:
+    text = prime.value if isinstance(prime, PrimeName) else str(prime)
+    return text.lower().replace(" ", "-")
+
+
+def _token_type(protocol: Protocol, chain: str, token_name: str) -> str:
+    if protocol in ATOKEN_PROTOCOLS:
+        return "atoken"
+
+    if protocol in ERC4626_PROTOCOLS:
+        return "erc4626"
+
+    if protocol == Protocol.CURVE:
+        return "curve"
+
+    if protocol in UNISWAP_STYLE_PROTOCOLS:
+        if "LP" in token_name.upper():
+            return "uni_v3_lp"
+        return "uni_v3_pool"
+
+    if protocol == Protocol.CENTRIFUGE:
+        if chain == "plume":
+            return "centrifuge_feeder"
+        return "centrifuge"
+
+    if protocol == Protocol.ANCHORAGE:
+        return "anchorage"
+
+    if protocol in L1_PSM_PROTOCOLS | L2_PSM_PROTOCOLS:
+        return "psm3"
+
+    return "erc20"
+
+
+def _allocation_type(protocol: Protocol) -> str:
+    if protocol in L1_PSM_PROTOCOLS | L2_PSM_PROTOCOLS:
+        return "psm3"
+    return "allocation"
+
+
+def _version_from_package_metadata() -> str:
+    return importlib.metadata.version("axis-synome")
+
+
+def _axis_synome_git_commit() -> str:
+    repo_root = Path(__file__).resolve().parents[2]
+    try:
+        return subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], cwd=repo_root, text=True
+        ).strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return "unknown"
+
+
+def build_axis_synome_contract(
+    version: str | None = None,
+    axis_synome_git_commit: str | None = None,
+) -> AxisSynomeContract:
+    # Canonical ALM Proxy per (star, chain). This is the wallet that holds the
+    # operational allocation positions, and the wallet that every token entry on
+    # that (star, chain) binds to.
+    alm_proxy_by_key: dict[tuple[str, str], str] = {}
+    for member in AlmProxy:
+        deployment = member.value
+        chain = STL_CHAIN_BY_NETWORK.get(deployment.network)
+        if chain is None:
+            continue
+
+        star = _prime_to_star(deployment.prime.name)
+        alm_proxy_by_key[(star, chain)] = str(deployment.address).lower()
+
+    # All wallets to export per (star, chain): the canonical ALM Proxy first,
+    # then any additional SubProxy/treasury wallets. Additional wallets are
+    # appended rather than replacing the ALM Proxy, so both stay tracked.
+    # Value is a list of (address, role) so consumers can distinguish the
+    # canonical ALM proxy from additional SubProxy wallets.
+    proxies_by_key: dict[tuple[str, str], list[tuple[str, str]]] = {
+        key: [(address, PROXY_ROLE_ALM)] for key, address in alm_proxy_by_key.items()
+    }
+    for (prime, network), addresses in STL_ADDITIONAL_PROXIES.items():
+        chain = STL_CHAIN_BY_NETWORK.get(network)
+        if chain is None:
+            continue
+
+        star = _prime_to_star(prime.name)
+        for address in addresses:
+            address = str(address).lower()
+            existing = proxies_by_key.setdefault((star, chain), [])
+            if any(addr == address for addr, _ in existing):
+                raise ValueError(
+                    f"additional proxy {address} for {star}/{chain} duplicates a "
+                    "canonical ALM proxy; remove it from STL_ADDITIONAL_PROXIES"
+                )
+            existing.append((address, PROXY_ROLE_SUBPROXY))
+
+    entries: list[dict[str, Any]] = []
+    seen_entry_keys: set[tuple[str, str, str]] = set()
+    missing_proxy_keys: set[tuple[str, str]] = set()
+    for prime_name, assets in ASSETS_BY_PRIME.items():
+        star = _prime_to_star(prime_name)
+        if star not in {"spark", "grove"}:
+            continue
+
+        for asset in assets:
+            chain = STL_CHAIN_BY_NETWORK.get(asset.network)
+            if chain is None:
+                continue
+
+            wallet = alm_proxy_by_key.get((star, chain))
+            if wallet is None:
+                # Assets exist for this (star, chain) but no ALM proxy is
+                # defined, so they would silently vanish from the export. Fail
+                # loudly instead, mirroring the duplicate-entry guard below.
+                missing_proxy_keys.add((star, chain))
+                continue
+
+            contract_address = str(asset.address).lower()
+            entry_key = (chain, contract_address, wallet)
+            if entry_key in seen_entry_keys:
+                raise ValueError(
+                    "duplicate token entry for "
+                    f"chain={chain} contract={contract_address} wallet={wallet}; "
+                    "resolve the conflicting Asset definitions in assets_by_prime"
+                )
+            seen_entry_keys.add(entry_key)
+
+            entries.append({
+                "contract_address": contract_address,
+                "wallet_address": wallet,
+                "asset_address": str(asset.underlying_asset_address).lower(),
+                "star": star,
+                "chain": chain,
+                "protocol": _slug(asset.protocol.value),
+                "allocation_type": _allocation_type(asset.protocol),
+                "token_type": _token_type(asset.protocol, chain, asset.token.value),
+            })
+
+    # STL positions with no Atlas backing. These bind to the same ALM Proxy and
+    # share the duplicate / missing-proxy guards above, but carry their STL
+    # protocol, allocation_type and token_type verbatim rather than deriving
+    # them — the legacy pol/asset/proxy values are not a function of protocol.
+    for prime_name, missing_assets in MISSING_FROM_ATLAS_BY_PRIME.items():
+        star = _prime_to_star(prime_name)
+        if star not in {"spark", "grove"}:
+            continue
+
+        for missing in missing_assets:
+            chain = STL_CHAIN_BY_NETWORK.get(missing.network)
+            if chain is None:
+                continue
+
+            # risk_capital holdings bind to an explicit SubProxy wallet; all
+            # other rows bind to the canonical ALM Proxy for the (star, chain).
+            if missing.wallet_address is not None:
+                wallet = str(missing.wallet_address).lower()
+            else:
+                wallet = alm_proxy_by_key.get((star, chain))
+                if wallet is None:
+                    missing_proxy_keys.add((star, chain))
+                    continue
+
+            contract_address = str(missing.address).lower()
+            entry_key = (chain, contract_address, wallet)
+            if entry_key in seen_entry_keys:
+                raise ValueError(
+                    "duplicate token entry for "
+                    f"chain={chain} contract={contract_address} wallet={wallet}; "
+                    "resolve the conflicting Asset definitions in assets_by_prime "
+                    "and assets_missing_from_atlas"
+                )
+            seen_entry_keys.add(entry_key)
+
+            entries.append({
+                "contract_address": contract_address,
+                "wallet_address": wallet,
+                "asset_address": (
+                    str(missing.underlying_asset_address).lower()
+                    if missing.underlying_asset_address is not None
+                    else None
+                ),
+                "star": star,
+                "chain": chain,
+                "protocol": missing.protocol,
+                "allocation_type": missing.allocation_type,
+                "token_type": missing.token_type,
+            })
+
+    if missing_proxy_keys:
+        raise ValueError(
+            "assets defined for (star, chain) with no canonical ALM proxy: "
+            f"{sorted(missing_proxy_keys)}; add the ALM proxy to the AlmProxy enum"
+        )
+
+    assets_by_prime_export: dict[str, list[TokenEntryModel]] = {}
+    for entry in entries:
+        assets_by_prime_export.setdefault(entry["star"], []).append(TokenEntryModel(**entry))
+
+    alm_proxy_export: dict[str, dict[str, list[ProxyEntry]]] = {}
+    for (star, chain), addr_roles in proxies_by_key.items():
+        alm_proxy_export.setdefault(star, {})[chain] = [
+            ProxyEntry(star=star, chain=chain, address=address, role=role)
+            for address, role in addr_roles
+        ]
+
+    return AxisSynomeContract(
+        version=version or _version_from_package_metadata(),
+        axis_synome_git_commit=axis_synome_git_commit or _axis_synome_git_commit(),
+        axis_synome=AxisSynomeModel(
+            spec=SpecModel(
+                asc=AscModel(
+                    entities=EntitiesModel(
+                        assets_by_prime=AssetsByPrimeContainer(entries=assets_by_prime_export),
+                        alm_proxies=AlmProxiesContainer(proxies=alm_proxy_export),
+                    )
+                )
+            )
+        ),
+    )
+
+
+def export_axis_synome_contract(
+    data_path: Path,
+    schema_path: Path,
+    version: str | None,
+    axis_synome_git_commit: str | None,
+) -> None:
+    config = build_axis_synome_contract(
+        version=version,
+        axis_synome_git_commit=axis_synome_git_commit,
+    )
+
+    data_path.parent.mkdir(parents=True, exist_ok=True)
+    schema_path.parent.mkdir(parents=True, exist_ok=True)
+
+    data_path.write_text(config.model_dump_json(indent=2, by_alias=True), encoding="utf-8")
+
+    schema = AxisSynomeContract.model_json_schema(by_alias=True)
+    schema_path.write_text(json.dumps(schema, indent=2), encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Export axis-synome entities contract JSON and pydantic schema."
+    )
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=Path("generated/stl/axis_synome_entities.json"),
+        help="Output JSON data path",
+    )
+    parser.add_argument(
+        "--schema-out",
+        type=Path,
+        default=Path("generated/stl/axis_synome_entities.schema.json"),
+        help="Output JSON schema path",
+    )
+    parser.add_argument(
+        "--version",
+        type=str,
+        default=None,
+        help="Version string embedded in exported config (default resolves from pyproject metadata)",
+    )
+    parser.add_argument(
+        "--git-commit",
+        type=str,
+        default=None,
+        help="axis-synome git commit hash embedded in exported config (default resolves from git)",
+    )
+
+    args = parser.parse_args()
+    export_axis_synome_contract(
+        args.out,
+        args.schema_out,
+        version=args.version,
+        axis_synome_git_commit=args.git_commit,
+    )
+
+
+if __name__ == "__main__":
+    main()

{axis_synome-0.1.0.dev66 → axis_synome-0.1.0.dev68}/src/axis_synome/spec/asc/entities/alm_proxies.py

@@ -209,8 +209,18 @@ class AlmProxy(Enum):
     GROVE_MONAD = GROVE_MONAD_ALM_PROXY
 
 
-# Temporary STL compatibility overrides while tracker config migrates.
-STL_ALM_PROXY_ADDRESS_OVERRIDES: Final[dict[tuple[PrimeAgent, Network], str]] = {
-    (PrimeAgent.SPARK, Network.ETHEREUM_MAINNET): "0x3300f198988e4c9c63f75df86de36421f06af8c4",
-    (PrimeAgent.GROVE, Network.ETHEREUM_MAINNET): "0x1369f7b2b38c76b6478c0f0e66d94923421891ba",
+# Additional ALM-controlled wallets that are NOT the canonical ALM Proxy but
+# must still be tracked by downstream consumers. The canonical ALM Proxy holds
+# the operational allocation positions; these SubProxy ("risk capital" /
+# treasury) wallets hold capital separately and are exported alongside the ALM
+# Proxy for the same (Prime, Network) rather than replacing it.
+STL_ADDITIONAL_PROXIES: Final[dict[tuple[PrimeAgent, Network], list[str]]] = {
+    # Spark SubProxy — Atlas A.6.1.1.1.2.1.1.3.1.1.2.
+    (PrimeAgent.SPARK, Network.ETHEREUM_MAINNET): [
+        "0x3300f198988e4c9c63f75df86de36421f06af8c4",
+    ],
+    # Grove SubProxy — Atlas A.6.1.1.2.2.1.1.3.1.1.2.
+    (PrimeAgent.GROVE, Network.ETHEREUM_MAINNET): [
+        "0x1369f7b2b38c76b6478c0f0e66d94923421891ba",
+    ],
 }

{axis_synome-0.1.0.dev66 → axis_synome-0.1.0.dev68}/src/axis_synome/spec/asc/entities/assets_by_prime.py

@@ -263,6 +263,47 @@ ASSETS_BY_PRIME: dict[PrimeName, list[Asset]] = {
             underlying_asset_source="A.6.1.1.2.2.6.1.3.4.1.1.2.2.2",
             categories={AssetCategory.LENDING_MARKET},
         ),
+        # Galaxy Arch CLOs. The GACLO-1 token is on Avalanche while deposits are
+        # made on Ethereum Mainnet, so the Atlas-recorded Underlying Asset
+        # Address is mainnet USDC (0xA0b8…) per the Instance Configuration
+        # Document. Network is Avalanche to match the token deployment chain.
+        Asset(
+            token=Token.GACLO_1,
+            network=Network.AVALANCHE,
+            protocol=Protocol.GALAXY,
+            address=EvmAddress("0x2C0aDFF8e114f3cA106051144353aC703D24B901"),
+            source="A.6.1.1.2.2.6.1.3.1.9.1.2.2.1",
+            underlying_asset=Token.USDC,
+            underlying_asset_address=EvmAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+            underlying_asset_source="A.6.1.1.2.2.6.1.3.1.9.1.2.2.3",
+            categories={AssetCategory.REAL_WORLD_ASSET},
+        ),
+        Asset(
+            token=Token.ACRDX,
+            network=Network.PLUME,
+            protocol=Protocol.CENTRIFUGE,
+            address=EvmAddress("0x9477724Bb54AD5417de8Baff29e59DF3fB4DA74f"),
+            source="A.6.1.1.2.2.6.1.3.5.1.1.2.2.1",
+            underlying_asset=Token.USDC,
+            underlying_asset_address=EvmAddress("0x222365EF19F7947e5484218551B56bb3965Aa7aF"),
+            underlying_asset_source="A.6.1.1.2.2.6.1.3.5.1.1.2.2.2",
+            categories={AssetCategory.REAL_WORLD_ASSET},
+        ),
+        # Monad Uniswap AUSD/USDC pool. The Atlas Underlying Asset Address node
+        # records USDC (0xA0b8…), which is the asset supplied by the Grove
+        # Liquidity Layer; the token name carries no "LP" marker so the export
+        # derives token_type "uni_v3_pool".
+        Asset(
+            token=Token.UNISWAP_AUSD_USDC_POOL,
+            network=Network.MONAD,
+            protocol=Protocol.UNISWAP,
+            address=EvmAddress("0x6B405DCA74897c9442d369DcF6c0EC230f7E1c7C"),
+            source="A.6.1.1.2.2.6.1.3.1.12.1.2.2.1",
+            underlying_asset=Token.USDC,
+            underlying_asset_address=EvmAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+            underlying_asset_source="A.6.1.1.2.2.6.1.3.1.12.1.2.2.2",
+            categories={AssetCategory.CASH_STABLECOIN},
+        ),
     ],
     PrimeName.OBEX: [
         Asset(
@@ -410,17 +451,12 @@ ASSETS_BY_PRIME: dict[PrimeName, list[Asset]] = {
             underlying_asset_source="A.6.1.1.1.2.6.1.3.1.2.1.2.2.2",
             categories={AssetCategory.LENDING_MARKET},
         ),
-        Asset(
-            token=Token.SP_USDC,
-            network=Network.ETHEREUM_MAINNET,
-            protocol=Protocol.ARKIS,
-            address=EvmAddress("0x377C3bd93f2a2984E1E7bE6A5C22c525eD4A4815"),
-            source="A.6.1.1.1.2.6.1.3.1.10.1.2.2.1",
-            underlying_asset=Token.USDC,
-            underlying_asset_address=EvmAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
-            underlying_asset_source="A.6.1.1.1.2.6.1.3.1.10.1.2.2.2",
-            categories={AssetCategory.LENDING_MARKET},
-        ),
+        # TODO(axis-synome owners): the real Arkis vault (expected ~0x38464507…)
+        # is not yet defined here. The previous ARKIS entry reused the SparkLend
+        # USDC aToken address (0x377C3bd9…, kept below under SPARKLEND_PROTOCOL),
+        # which collapsed two distinct positions into one. It has been removed;
+        # add the Arkis vault with its own address once the Atlas reference is
+        # available.
         Asset(
             token=Token.BUIDL_I,
             network=Network.ETHEREUM_MAINNET,