yearn-treasury 0.1.7__cp310-cp310-win32.whl

yearn_treasury/__init__.py

@@ -0,0 +1,19 @@
+import warnings
+
+from yearn_treasury import budget
+from yearn_treasury._db import prepare_db
+from yearn_treasury._logging import setup_eth_portfolio_logging
+
+prepare_db()
+setup_eth_portfolio_logging()
+
+
+warnings.filterwarnings(
+    "ignore",
+    message=".Event log does not contain enough topics for the given ABI.",
+    category=UserWarning,
+    module="brownie.network.event",
+)
+
+
+__all__ = ["budget"]

yearn_treasury/_db.py

@@ -0,0 +1,50 @@
+"""
+Database labeling utility for Yearn Treasury.
+
+This module provides a helper function to set up address nicknames
+in the database, mapping key Yearn Treasury addresses to human-readable
+labels. It is used during database preparation to ensure that wallet
+addresses are clearly labeled in analytics and reporting.
+
+When Yearn Treasury is imported, this module maps important addresses
+to descriptive nicknames within the DAO Treasury database entity system
+for improved data clarity and prettification of reports.
+"""
+
+import time
+
+import dao_treasury._docker
+from dao_treasury.db import Address, init_db
+from y import Network
+from y.constants import CHAINID
+
+from yearn_treasury import constants
+
+
+def prepare_db() -> None:
+    """
+    Set up address nicknames in the Yearn Treasury database.
+
+    Maps key Yearn Treasury addresses to human-readable labels for improved
+    clarity in analytics and reporting. This function is typically called
+    during database preparation to ensure wallet addresses are labeled
+    within the DAO Treasury database entity system.
+    """
+    # We need to start the postgres container earlier than dao-treasury does
+    dao_treasury._docker.up("postgres")
+
+    time.sleep(5)
+
+    init_db()
+
+    chad = {Network.Mainnet: "y", Network.Fantom: "f"}[CHAINID]  # type: ignore [index]
+
+    labels = {
+        constants.TREASURY_MULTISIG: "Yearn Treasury",
+        constants.YCHAD_MULTISIG: f"Yearn {chad}Chad Multisig",
+        # constants.STRATEGIST_MULTISIG: "Yearn Strategist Multisig",
+        # This wallet is an EOA that has been used to assist in bridging tokens across chains.
+        "0x5FcdC32DfC361a32e9d5AB9A384b890C62D0b8AC": "Bridge Assistooor EOA",
+    }
+
+    Address.set_nicknames(labels)

yearn_treasury/_ens.py

@@ -0,0 +1,30 @@
+"""
+ENS resolver and event topic utilities for Yearn Treasury.
+
+This module defines the ENS resolver contract and event topic set
+used for dynamic vault discovery and event processing. It supports
+vault mapping and analytics by enabling on-chain lookups and event
+filtering for Yearn vaults.
+
+Key Responsibilities:
+    - Provide the ENS resolver contract for vault registry lookups.
+    - Construct event topic sets for AddressChanged events.
+    - Used by vault discovery, analytics, and reporting modules.
+"""
+
+from typing import Final
+
+from brownie import web3
+from web3._utils.abi import filter_by_name
+from web3._utils.events import construct_event_topic_set
+from y import Contract
+
+resolver: Final[Contract] = Contract("0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41")
+
+topics: Final = construct_event_topic_set(
+    filter_by_name("AddressChanged", resolver.abi)[0],  # type: ignore [arg-type]
+    web3.codec,
+    {"node": web3.ens.namehash("v2.registry.ychad.eth")},  # type: ignore [union-attr]
+)
+
+__all__ = ["resolver", "topics"]

yearn_treasury/_logging.py

@@ -0,0 +1,41 @@
+"""
+Error log suppression utilities for the Yearn Treasury exporter.
+
+This module suppresses noisy or irrelevant eth-portfolio error logs for specific
+token addresses that are known to be deprecated or otherwise unpricable.
+
+To suppress logs for additional tokens, add their addresses to the
+`suppress_logs_for[Network.<chain>]` mapping. The rest will be done
+automatically on package import.
+"""
+
+from typing import Final
+
+from cchecksum import to_checksum_address
+from eth_portfolio._utils import SUPPRESS_ERROR_LOGS
+from eth_typing import HexAddress
+from y import Network
+
+from yearn_treasury.constants import CHAINID
+
+suppress_logs_for: Final[dict[Network, list[HexAddress]]] = {
+    Network.Mainnet: [
+        "0xBF7AA989192b020a8d3e1C65a558e123834325cA",  # unpriceable yvWBTC - This vault had a bug and does not have a pricePerShare
+        "0x5aFE3855358E112B5647B952709E6165e1c1eEEe",  # SAFE - This was not tradeable at the time of the first airdrops
+        "0x718AbE90777F5B778B52D553a5aBaa148DD0dc5D",  # yvCurve-alETH - The underlying curve pool had an issue and is unpriceable
+        "0x3819f64f282bf135d62168C1e513280dAF905e06",  # HDRN
+        "0x5fAa989Af96Af85384b8a938c2EdE4A7378D9875",  # GAL
+    ],
+}
+
+
+def setup_eth_portfolio_logging() -> None:
+    """
+    Suppress eth-portfolio error logs for specific tokens on the current chain.
+
+    Appends token addresses from the suppress_logs_for mapping (for the current
+    CHAINID) to the SUPPRESS_ERROR_LOGS list, preventing error logs for these
+    tokens from being emitted during analytics and reporting.
+    """
+    for token in suppress_logs_for.get(CHAINID, []):  # type: ignore [call-overload]
+        SUPPRESS_ERROR_LOGS.append(to_checksum_address(token))

yearn_treasury/address_labels.yaml

@@ -0,0 +1,39 @@
+1:
+  Yearn Treasury V1:
+    - "0xb99a40fcE04cb740EB79fC04976CA15aF69AaaaE"
+  Yearn Strategist Multisig: # refactor this to do from python from constants file
+    - "0x16388463d60FFE0661Cf7F1f31a7D658aC790ff7"
+  yMechs Multisig:
+    - "0x2C01B4AD51a67E2d8F02208F54dF9aC4c0B778B6"
+  ySwap Multisig:
+    - "0x7d2aB9CA511EBD6F03971Fb417d3492aA82513f0"
+  Yearn KP3R Wallet:
+    - "0x8d12a197cb00d4747a1fe03395095ce2a5cc6819"
+  Token Dumper Multisig:
+    - "0xC001d00d425Fa92C4F840baA8f1e0c27c4297a0B"
+  Cowswap Multisig:
+    - "0xA03be496e67Ec29bC62F01a428683D7F9c204930"
+  dYFI Redemption Contract:
+    - "0x7dC3A74F0684fc026f9163C6D5c3C99fda2cf60a"
+  Yearn veFarming Multisig:
+    - "0x4fc1b14cD213e7B6212145Ba4f180C3d53d1A11e"
+  CRV Buyer Contract (DAI):
+    - "0x0000000000007F150Bd6f54c40A34d7C3d5e9f56"
+  CRV Buyer Contract (USDT):
+    - "0x0000000000005117Dd3A72E64a705198753FDD54"
+  YFI Buyer Contract:
+    - "0x0000000000884A0E1fB44F9E24Fa3BDB19514fAE"
+    - "0x0000000000051666BBfBB42925C3eE5d50cF6B10"
+  Multichain Fantom Bridge:
+    - "0xC564EE9f21Ed8A2d8E7e76c085740d5e4c5FaFbE"
+  yLockers Multisig:
+    - "0x4444AAAACDBa5580282365e25b16309Bd770ce4a"
+  yRoboTreasury Treasury Contract:
+    - "0xEf77cc176c748d291EfB6CdC982c5744fC7211c8"
+  yRoboTreasury Stables Reserve:
+    - "0x278374fFb10B7D16E7633444c13e6E565EA57c28"
+  yearn.fi Dutch Auctions:
+    - "0x861fE45742f70054917B65bE18904662bD0dBd30"
+250:
+  Yearn Strategist Multisig:
+    - "0x72a34AbafAB09b15E7191822A679f28E067C4a16"

yearn_treasury/budget/__init__.py

@@ -0,0 +1,6 @@
+from yearn_treasury.budget._request import BudgetRequest
+from yearn_treasury.budget._requests import approved_requests, budget_requests, rejected_requests
+
+# TODO test
+
+__all__ = ["BudgetRequest", "budget_requests", "approved_requests", "rejected_requests"]

yearn_treasury/budget/_request.py

@@ -0,0 +1,43 @@
+"""
+Budget request data model for Yearn Treasury.
+
+This module defines the BudgetRequest dataclass, which models a single
+budget request and its state. It provides methods for checking approval,
+rejection, streaming, vesting, and payment status.
+"""
+
+from dataclasses import dataclass
+from logging import getLogger
+from typing import Final, final
+
+logger: Final = getLogger(__name__)
+
+
+@final
+@dataclass(frozen=True)
+class BudgetRequest:
+    id: int
+    number: int
+    title: str
+    state: str
+    url: str
+    created_at: str
+    updated_at: str
+    closed_at: str | None
+    body: str | None
+    labels: set[str]
+
+    def is_approved(self) -> bool:
+        return "approved" in self.labels
+
+    def is_rejected(self) -> bool:
+        return "rejected" in self.labels
+
+    def is_stream(self) -> bool:
+        return "stream" in self.labels
+
+    def is_vesting(self) -> bool:
+        return "vesting" in self.labels
+
+    def is_paid(self) -> bool:
+        return "paid" in self.labels

yearn_treasury/budget/_requests.py

@@ -0,0 +1,96 @@
+"""
+Budget request ingestion and filtering for Yearn Treasury.
+
+This module fetches budget requests from GitHub, parses them into
+BudgetRequest objects, and provides lists of approved and rejected
+requests.
+"""
+
+import os
+import time
+from typing import Any, Final
+
+import requests
+
+from yearn_treasury.budget._request import BudgetRequest
+
+API_URL: Final = "https://api.github.com/repos/yearn/budget/issues"
+"""URL to fetch issues from the repo."""
+
+# Optionally use a GitHub personal access token for higher API rate limits.
+# TODO move this to envs file and document
+_TOKEN: Final = os.environ.get("GITHUB_TOKEN")
+_HEADERS: Final = {"Authorization": f"token {_TOKEN}"} if _TOKEN else {}
+
+
+def fetch_brs() -> list[BudgetRequest]:
+    # Use parameters to fetch issues in all states, up to 100 per page.
+    current_page = 1
+    params = {"state": "all", "per_page": 100, "page": current_page}
+
+    brs = []
+    retries = 0
+    while True:
+        response = _make_get_request(params=params)
+
+        data: list[dict] = response.json()  # type: ignore [type-arg]
+        if not data:  # If the current page is empty, we are done.
+            break
+
+        for item in data:
+            # GitHub's issues API returns pull requests as well.
+            if "pull_request" in item:
+                continue
+
+            # TODO labels table in db (also dataclass) with the descriptions included
+            # Extract the label names (tags) from the "labels" key.
+            label_objs: list[dict] = item.get("labels", [])  # type: ignore [type-arg]
+            labels = {label.get("name") for label in label_objs}
+
+            if "budget request" not in labels:
+                continue
+
+            br = BudgetRequest(
+                id=item.get("id"),  # type: ignore [arg-type]
+                number=item.get("number"),  # type: ignore [arg-type]
+                title=item.get("title"),  # type: ignore [arg-type]
+                state=item.get("state"),  # type: ignore [arg-type]
+                url=item.get("html_url"),  # type: ignore [arg-type]
+                created_at=item.get("created_at"),  # type: ignore [arg-type]
+                updated_at=item.get("updated_at"),  # type: ignore [arg-type]
+                closed_at=item.get("closed_at"),  # type: ignore [arg-type]
+                body=item.get("body"),  # type: ignore [arg-type]
+                labels=labels,  # type: ignore [arg-type]
+            )
+            brs.append(br)
+
+        # Move on to the next page.
+        current_page += 1
+        params["page"] = current_page
+
+    return brs
+
+
+def _make_get_request(params: dict[str, Any]) -> Any:
+    retries = 0
+    while True:
+        try:
+            response = requests.get(API_URL, headers=_HEADERS, params=params)
+            response.raise_for_status()
+            return response
+        except requests.HTTPError as e:
+            if "rate limit exceeded" in str(e):
+                print("Github API rate limited...")
+            elif retries < 5:
+                print(e)
+            else:
+                raise ConnectionError(
+                    f"Failed to fetch issues: {response.status_code} {response.text}"
+                ) from e
+            retries += 1
+            time.sleep(5 * (retries + 1))
+
+
+budget_requests: Final = fetch_brs()
+approved_requests: Final = [r for r in budget_requests if r.is_approved()]
+rejected_requests: Final = [r for r in budget_requests if r.is_rejected()]

yearn_treasury/constants.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+from typing import Final
+
+import y.constants
+from eth_typing import BlockNumber
+from y import Network, convert
+
+CHAINID: Final = y.constants.CHAINID
+
+EEE_ADDRESS: Final = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+ZERO_ADDRESS: Final = "0x0000000000000000000000000000000000000000"
+
+_YEARN_TREASURY_ROOT_DIR: Final = Path(__file__).parent
+
+TREASURY_MULTISIGS: Final = {
+    Network.Mainnet: "0x93A62dA5a14C80f265DAbC077fCEE437B1a0Efde",
+    Network.Fantom: "0x89716Ad7EDC3be3B35695789C475F3e7A3Deb12a",
+    Network.Arbitrum: "0x1deb47dcc9a35ad454bf7f0fcdb03c09792c08c1",
+    Network.Optimism: "0x84654e35E504452769757AAe5a8C7C6599cBf954",
+    Network.Base: "0x02ff746D8cb62709aEEc611CeC9B17d7dD1D3480",
+}
+
+YCHAD_MULTISIGS: Final = {
+    Network.Mainnet: "0xFEB4acf3df3cDEA7399794D0869ef76A6EfAff52",
+    Network.Fantom: "0xC0E2830724C946a6748dDFE09753613cd38f6767",
+    Network.Gnosis: "0x22eAe41c7Da367b9a15e942EB6227DF849Bb498C",
+    Network.Arbitrum: "0xb6bc033d34733329971b938fef32fad7e98e56ad",
+    Network.Optimism: "0xF5d9D6133b698cE29567a90Ab35CfB874204B3A7",
+    Network.Base: "0xbfAABa9F56A39B814281D68d2Ad949e88D06b02E",
+}
+
+YSWAP_MULTISIGS: Final = {
+    Network.Mainnet: "0x7d2aB9CA511EBD6F03971Fb417d3492aA82513f0",
+}
+
+
+if CHAINID not in TREASURY_MULTISIGS or CHAINID not in YCHAD_MULTISIGS:
+    raise RuntimeError(f"{Network(CHAINID)} is not supported")
+
+
+TREASURY_MULTISIG: Final = convert.to_address(TREASURY_MULTISIGS[CHAINID])  # type: ignore [index]
+
+YCHAD_MULTISIG: Final = convert.to_address(YCHAD_MULTISIGS[CHAINID])  # type: ignore [index]
+
+__yswap_multisig = YSWAP_MULTISIGS.get(CHAINID)  # type: ignore [call-overload]
+YSWAP_MULTISIG: Final = convert.to_address(__yswap_multisig) if __yswap_multisig else None
+
+_TREASURY_WALLETS: Final = {
+    Network.Mainnet: {
+        TREASURY_MULTISIG,
+        YCHAD_MULTISIG,
+        "0xb99a40fcE04cb740EB79fC04976CA15aF69AaaaE",  # Yearn Treasury V1
+        "0x5f0845101857d2A91627478e302357860b1598a1",  # Yearn KP3R Wallet
+        YSWAP_MULTISIG,
+        "0x2C01B4AD51a67E2d8F02208F54dF9aC4c0B778B6",  # yMechs Multisig
+        "0xE376e8e8E3B0793CD61C6F1283bA18548b726C2e",  # Fee Reimbursement Stash
+        "0xC001d00d425Fa92C4F840baA8f1e0c27c4297a0B",  # New token dumping wallet
+        "0x4fc1b14cD213e7B6212145Ba4f180C3d53d1A11e",  # veFarming wallet
+    },
+}
+
+TREASURY_WALLETS: Final = {
+    convert.to_address(address) for address in _TREASURY_WALLETS.get(CHAINID, set())  # type: ignore [call-overload]
+}
+
+
+YFI: Final = {
+    Network.Mainnet: "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e",
+    Network.Fantom: "0x29b0Da86e484E1C0029B56e817912d778aC0EC69",
+    Network.Arbitrum: "0x82e3A8F066a6989666b031d916c43672085b1582",
+    Network.Polygon: "0xDA537104D6A5edd53c6fBba9A898708E465260b6",
+}.get(
+    CHAINID, None
+)  # type: ignore [call-overload]
+
+
+class Args:
+    wallets: Final[Path] = _YEARN_TREASURY_ROOT_DIR / "wallets.yaml"
+    # TODO: update dashboard def to use this label (we will need to migrate the provisioning files to yearn-treasury but we need to do this anyway for yearn-specific additions)
+    label: Final[str] = "Treasury"  # "Yearn"
+    first_tx_block: Final = BlockNumber({Network.Mainnet: 10_502_337}.get(CHAINID, 0))  # type: ignore [call-overload]
+    export_start_block: Final = first_tx_block
+
+    sort_rules: Final[Path] = _YEARN_TREASURY_ROOT_DIR / "rules"
+    """The path where the sort rules for dao-treasury are defined."""
+
+    nicknames: Final[Path] = _YEARN_TREASURY_ROOT_DIR / "address_labels.yaml"
+    """The path where yearn-treasury's address nicknames are defined."""
+
+    custom_bucket: Final[list[str]] = [f"{YFI}:YFI"]
+    """Custom bucket mapping for token addresses, tells DAO Treasury to categorize YFI and YFI wrappers as special bucket 'YFI'."""

yearn_treasury/main.py

@@ -0,0 +1,175 @@
+"""
+Command-line interface for the Yearn Treasury exporter.
+
+This module provides the `yearn-treasury` CLI, which connects to a Brownie network
+(based on the `--network` option or the `BROWNIE_NETWORK_ID` environment variable),
+periodically snapshots treasury metrics, and pushes them to Victoria Metrics.
+It also launches Yearn Treasury's Grafana dashboard and an optional renderer for visual reports.
+
+Example:
+    Run export every 12 hours on mainnet:
+
+    .. code-block:: bash
+
+        yearn-treasury run --network mainnet --interval 12h
+
+CLI Options:
+    --network         Brownie network identifier (default: mainnet)
+    --interval        Time interval between datapoints (default: 12h)
+    --concurrency     Max number of historical blocks to export concurrently (default: 30)
+    --daemon          Run as a background daemon (currently unsupported)
+    --grafana-port    Port for the Grafana dashboard (default: 3004)
+    --victoria-port   Port for the Victoria metrics endpoint (default: 8430)
+    --start-renderer  Start the Grafana renderer container for dashboard image export
+    --renderer-port   Port for the renderer service (default: 8080)
+"""
+
+import asyncio
+import os
+from argparse import ArgumentParser
+from typing import Final, final
+
+from yearn_treasury import yteams
+
+parser = ArgumentParser(description="Treasury CLI")
+subparsers = parser.add_subparsers(dest="command", required=True)
+
+run_parser = subparsers.add_parser("run", help="Run the treasury export tool")
+run_parser.add_argument(
+    "--network",
+    type=str,
+    help="The brownie network identifier for the RPC to use. Overrides BROWNIE_NETWORK_ID env var if unset.",
+    default="mainnet",
+)
+run_parser.add_argument(
+    "--interval",
+    type=str,
+    help="The time interval between datapoints. Default: 12h",
+    default="12h",
+)
+run_parser.add_argument(
+    "--concurrency",
+    type=int,
+    help="The max number of historical blocks to export concurrently. default: 30",
+    default=30,
+)
+run_parser.add_argument(
+    "--daemon",
+    action="store_true",
+    help="Run as a background daemon (currently unsupported).",
+)
+run_parser.add_argument(
+    "--grafana-port",
+    type=int,
+    help="Port for the Grafana dashboard where you can view your data. Default: 3004",
+    default=3004,
+)
+run_parser.add_argument(
+    "--victoria-port",
+    type=int,
+    help="Port for the Victoria metrics reporting endpoint. Default: 8430",
+    default=8430,
+)
+run_parser.add_argument(
+    "--start-renderer",
+    action="store_true",
+    help="If set, the Grafana renderer container will be started for dashboard image export. By default, only the grafana container is started.",
+)
+run_parser.add_argument(
+    "--renderer-port",
+    type=int,
+    help="Port for the service that renders visual reports. Default: 8080",
+    default=8080,
+)
+args = run_parser.parse_args()
+
+# Set BROWNIE_NETWORK_ID from --network flag if not already set
+os.environ.setdefault("BROWNIE_NETWORK_ID", args.network)
+BROWNIE_NETWORK = os.environ["BROWNIE_NETWORK_ID"]
+
+
+# TODO: run forever arg
+def main() -> None:
+    """
+    Connect to the configured Brownie network, clean up the database, and start the export loop.
+
+    This function is registered as a console script entrypoint under
+    ``yearn-treasury``. It performs the following steps:
+        1. Reads the ``BROWNIE_NETWORK_ID`` environment variable (populated from
+           the ``--network`` option or existing env var).
+        2. Connects to the specified Brownie network.
+        3. Merges local SHITCOINS into eth_portfolio's config to skip tokens we don't care about.
+        4. Drops any shitcoin transactions that might be in the database.
+        5. Constructs an immutable Args subclass to pass CLI parameters to
+           :func:`dao_treasury.main.export`.
+        6. Exports ports for external services into environment variables.
+        7. Runs both the DAO Treasury export and Yearn team revenue/expenses calculation concurrently under asyncio.
+    """
+    import dao_treasury.db
+    import eth_portfolio
+
+    from . import constants, rules, shitcoins
+
+    # Merge local SHITCOINS into eth_portfolio's config to skip tokens we don't care about
+    eth_portfolio.SHITCOINS[constants.CHAINID].update(shitcoins.SHITCOINS)  # type: ignore [index]
+
+    # Drop any shitcoin txs that might be in the db
+    dao_treasury.db._drop_shitcoin_txs()
+
+    @final
+    class Args(constants.Args):
+        """
+        Immutable container of CLI arguments for export and dashboard/renderer configuration.
+
+        Inherits from DAO Treasury's :class:`constants.Args` and is used to pass runtime
+        parameters to the DAO Treasury export and related services.
+        """
+
+        network: Final[str] = args.network
+        """Brownie network to connect to."""
+
+        interval: Final[str] = args.interval
+        """Time interval between snapshots."""
+
+        concurrency: Final[int] = args.concurrency
+        """The max number of historical blocks to export concurrently."""
+
+        grafana_port: Final[int] = args.grafana_port
+        """Grafana port."""
+
+        victoria_port: Final[int] = args.victoria_port
+        """Victoria metrics port."""
+
+        start_renderer: Final[bool] = args.start_renderer
+        """Boolean indicating whether to start the renderer container."""
+
+        renderer_port: Final[int] = args.renderer_port
+        """Report renderer port."""
+
+        daemon: Final[bool] = args.daemon
+        """Whether to run in daemon mode."""
+
+    import dao_treasury.main
+
+    # Export ports for external services (must come after import)
+    os.environ["DAO_TREASURY_GRAFANA_PORT"] = str(Args.grafana_port)
+    os.environ["DAO_TREASURY_RENDERER_PORT"] = str(Args.renderer_port)
+    os.environ["VICTORIA_PORT"] = str(Args.victoria_port)
+
+    async def yearn_wrapper():
+        """
+        Run the DAO Treasury export and Yearn team revenue/expenses calculation concurrently.
+
+        This coroutine gathers:
+            - The main DAO Treasury export process (dao_treasury.main.export)
+            - The Yearn teams' revenue and expenses calculation (yteams.calculate_teams_revenue_expenses)
+        """
+        return await asyncio.gather(
+            dao_treasury.main.export(Args),
+            yteams.calculate_teams_revenue_expenses(),
+        )
+
+    # Start the balance export routine
+    asyncio.get_event_loop().run_until_complete(yearn_wrapper())
+
+    rules  # I just put this here so the import isn't flagged as unused

yearn_treasury/py.typed

@@ -0,0 +1 @@
+

yearn_treasury/rules/__init__.py

@@ -0,0 +1,20 @@
+import os
+
+__ALRU_ENV_NAME = "ASYNC_LRU_ALLOW_SYNC"
+__ALRU_ENV_VAL = os.environ.get(__ALRU_ENV_NAME)
+os.environ[__ALRU_ENV_NAME] = "1"
+
+from yearn_treasury.rules.cost_of_revenue import *
+from yearn_treasury.rules.expense import *
+from yearn_treasury.rules.ignore import *
+from yearn_treasury.rules.other_expense import *
+from yearn_treasury.rules.other_income import *
+from yearn_treasury.rules.revenue import *
+
+if __ALRU_ENV_VAL is None:
+    os.environ.pop(__ALRU_ENV_NAME)
+else:
+    os.environ[__ALRU_ENV_NAME] = __ALRU_ENV_VAL
+
+del __ALRU_ENV_NAME
+del __ALRU_ENV_VAL

yearn_treasury/rules/constants.py

@@ -0,0 +1,15 @@
+from typing import Final
+
+from y import Network
+from y.constants import CHAINID
+
+EEE_ADDRESS: Final = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+ZERO_ADDRESS: Final = "0x0000000000000000000000000000000000000000"
+
+
+YFI: Final = {
+    Network.Mainnet: "0x0bc529c00C6401aEF6D220BE8C6Ea1667F6Ad93e",
+    Network.Fantom: "0x29b0Da86e484E1C0029B56e817912d778aC0EC69",
+    Network.Arbitrum: "0x82e3A8F066a6989666b031d916c43672085b1582",
+    Network.Polygon: "0xDA537104D6A5edd53c6fBba9A898708E465260b6",
+}[CHAINID]

yearn_treasury/rules/cost_of_revenue/__init__.py

@@ -0,0 +1 @@
+from yearn_treasury.rules.cost_of_revenue.gas import *