Artifex/tests/test_crypto_venture_cohort.py

from __future__ import annotations

import json

from agents.crypto_venture import CryptoVentureService
from control_plane.ventures.models import CompanyProposalStatus, CryptoJurisdictionPolicy, TokenNecessityClassification, TokenRedTeamFlag, VentureCohortMember, VentureTrack
from graph.bootstrap import champion_crypto_venture_cohort_graph_v1
from graph.crypto_venture_cohort import crypto_venture_cohort_registry
from graph.langgraph_runtime import LangGraphRuntime
from graph.models import GraphRun, GraphRunStatus
from model_router.router import ModelProvider, ModelRequestContract, ModelResponseContract, ModelRouter


class SolCryptoReviewProvider(ModelProvider):
    provider_name = "sol-test"

    def complete(self, request: ModelRequestContract) -> ModelResponseContract:
        prompt = request.prompt
        if "Counterfactual token necessity" in prompt:
            payload = {"classification": "TOKEN_STRONGLY_JUSTIFIED", "score": 78, "rationale": "Provider staking and slashing materially degrade with database credits.", "fiat_or_database_substitution": "Stablecoin can pay fees but cannot replace bonded slashing and public reputation."}
        elif "Independent Token Red Team" in prompt:
            payload = {"flags": ["BOOTSTRAP_PROBLEM"], "severity": "MEDIUM", "critique": "Provider supply bootstrap remains the main risk."}
        elif "Final Crypto IC" in prompt:
            payload = {"score_adjustment": 3, "decision": "PROTOCOL_VALIDATE", "rationale": "Token loop is plausible but needs testnet evidence."}
        else:
            payload = {}
        return ModelResponseContract("sol", json.dumps(payload), {})

    def health(self) -> str:
        return "AVAILABLE"


def service(router: ModelRouter | None = None) -> CryptoVentureService:
    return CryptoVentureService(router, web_research_available=False, generation_model_hint="qwen", research_model_hint="qwen", final_ic_model_hint="sol")


def test_crypto_track_and_token_gate_remove_weak_then_regenerate() -> None:
    svc = service()
    cohort = svc.prepare_cohort(size=2, concurrency=1)
    weak = svc._create_proposal(
        cohort.mandate,
        {"name": "Community Points SaaS", "product_thesis": "A normal SaaS dashboard.", "protocol_thesis": "A private database tracks points.", "token_thesis": "Community marketing token.", "token_utility": ["community"], "token_demand_loop": ["more users equals more token demand"]},
        "test",
        "OPEN_CRYPTO_CATEGORY",
    )
    VentureCohortMember.objects.create(cohort=cohort, proposal=weak)

    svc.token_necessity_gate(cohort)
    svc.regenerate_rejected_slots(cohort)
    weak.refresh_from_db()

    assert weak.status == CompanyProposalStatus.REJECTED
    assert weak.metadata["routed_to_saas"] is False
    assert cohort.members.count() == 0
    assert cohort.metrics["regeneration_policy"].startswith("V0.2")


def test_sol_counterfactual_red_team_and_final_ic_are_used() -> None:
    svc = service(ModelRouter({"sol": SolCryptoReviewProvider()}))
    cohort = svc.prepare_cohort(size=1, concurrency=1)
    proposal = svc._create_proposal(cohort.mandate, svc._fallback_payload(0, "PROOF_ATTESTATION_MARKETS"), "test", "PROOF_ATTESTATION_MARKETS")
    VentureCohortMember.objects.create(cohort=cohort, proposal=proposal)

    token = svc.assess_token_necessity(proposal)
    red = svc.red_team_proposal(proposal)
    svc.tokenomics_simulation(cohort)
    review = svc.portfolio_crypto_ic(cohort)

    assert token.classification == TokenNecessityClassification.TOKEN_STRONGLY_JUSTIFIED
    assert token.metadata["sol_counterfactual_review"]
    assert TokenRedTeamFlag.BOOTSTRAP_PROBLEM in red.flags
    assert review.rankings[0]["sol_final_ic_review"]["score_adjustment"] == 3


def test_regulatory_negation_does_not_treat_disabled_sale_as_issuance_risk() -> None:
    svc = service()
    cohort = svc.prepare_cohort(size=1, concurrency=1)
    proposal = svc._create_proposal(cohort.mandate, svc._fallback_payload(0, "AGENT_TO_AGENT_PAYMENTS"), "test", "AGENT_TO_AGENT_PAYMENTS")

    policy = svc.regulatory_policy(proposal)

    assert policy.regulatory_manageability_score == 72
    assert policy.metadata["TOKEN_SALE_DISABLED"] is True
    assert CryptoJurisdictionPolicy.objects.get(proposal=proposal).legal_review_required is True


def test_tokenomics_simulation_is_proposal_specific() -> None:
    svc = service()
    cohort = svc.prepare_cohort(size=1, concurrency=1)
    low = svc._create_proposal(cohort.mandate, {**svc._fallback_payload(0, "AGENT_TO_AGENT_PAYMENTS"), "confidence": 0.35}, "test", "AGENT_TO_AGENT_PAYMENTS")
    high = svc._create_proposal(cohort.mandate, {**svc._fallback_payload(1, "DECENTRALIZED_AI_COMPUTE"), "confidence": 0.9}, "test", "DECENTRALIZED_AI_COMPUTE")

    low_sim = svc.simulate_tokenomics(low)
    high_sim = svc.simulate_tokenomics(high)

    assert low_sim.scenarios["EXPECTED_USAGE"]["users"] != high_sim.scenarios["EXPECTED_USAGE"]["users"]
    assert low_sim.scenarios["EXPECTED_USAGE"]["token_demand"] != high_sim.scenarios["EXPECTED_USAGE"]["token_demand"]
    assert "NATIVE_TOKEN_REMOVED" in low_sim.scenarios


def test_v02_pretoken_roles_security_and_launch_readiness() -> None:
    svc = service()
    cohort = svc.prepare_cohort(size=1, concurrency=1)
    proposal = svc._create_proposal(cohort.mandate, svc._fallback_payload(0, "DECENTRALIZED_AI_COMPUTE"), "test", "DECENTRALIZED_AI_COMPUTE")
    VentureCohortMember.objects.create(cohort=cohort, proposal=proposal)

    pretoken = svc.assess_pretoken_monetization(proposal)
    roles = svc.token_role_decomposition(proposal)
    model = svc.token_economic_model(proposal)
    svc.protocol_security_gate(cohort)
    readiness = svc.token_launch_readiness(proposal)

    assert pretoken.pre_token_monetization_potential > 0
    assert roles.stablecoin_counterfactual["MODEL_B_stablecoin_payment_native_bond"]
    assert model.average_fee > 0
    assert proposal.protocol_security_assessment.decision in {"PASS_FOR_TESTNET_DESIGN", "REVISE_SECURITY_MODEL", "BLOCK_TESTNET"}
    assert readiness.launch_readiness_status != "READY_FOR_HUMAN_LAUNCH_REVIEW"


def test_crypto_cohort_graph_real_gates_and_report() -> None:
    svc = service()
    version = champion_crypto_venture_cohort_graph_v1()
    graph_run = GraphRun.objects.create(execution_graph_version=version, current_node=version.graph_spec["entry"])

    LangGraphRuntime(crypto_venture_cohort_registry(svc, cohort_size=3, concurrency=1)).run_until_terminal_or_paused(graph_run)
    graph_run.refresh_from_db()

    cohort = graph_run.venture_cohorts.get()
    report = cohort.mandate.artifacts.get(artifact_type="CRYPTO_VENTURE_COHORT_REPORT")

    assert graph_run.status == GraphRunStatus.COMPLETE
    assert cohort.metadata["venture_track"] == VentureTrack.CRYPTO_PROTOCOL
    assert cohort.members.count() == 3
    assert cohort.metrics["protocol_security_gate_passed"] >= 1
    assert len(report.content["ranking"]) == 3
    assert len(report.content["top_3"]) <= 3