dao-treasury 0.0.29__cp310-cp310-musllinux_1_2_i686.whl → 0.0.31__cp310-cp310-musllinux_1_2_i686.whl

dao_treasury/db.py

@@ -8,6 +8,7 @@ This module defines Pony ORM entities for:
 - ERC-20 tokens and native coin placeholder (:class:`Token`)
 - Hierarchical transaction grouping (:class:`TxGroup`)
 - Treasury transaction records (:class:`TreasuryTx`)
+- Streams and StreamedFunds for streaming payments
 
 It also provides helper functions for inserting ledger entries,
 resolving integrity conflicts, caching transaction receipts,
@@ -21,15 +22,16 @@ from functools import lru_cache
 from logging import getLogger
 from os import path
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Final, Union, final
+from typing import TYPE_CHECKING, Dict, Final, Tuple, Union, final
+from datetime import date, datetime, time, timezone
 
-from a_sync import AsyncThreadPoolExecutor, a_sync
+from a_sync import AsyncThreadPoolExecutor
 from brownie import chain
 from brownie.convert.datatypes import HexString
 from brownie.exceptions import EventLookupError
 from brownie.network.event import EventDict, _EventItem
 from brownie.network.transaction import TransactionReceipt
-from eth_typing import ChecksumAddress, HexAddress
+from eth_typing import ChecksumAddress, HexAddress, HexStr
 from eth_portfolio.structs import (
     InternalTransfer,
     LedgerEntry,
@@ -68,6 +70,7 @@ _INSERT_THREAD = AsyncThreadPoolExecutor(1)
 _SORT_THREAD = AsyncThreadPoolExecutor(1)
 _SORT_SEMAPHORE = Semaphore(50)
 
+_UTC = timezone.utc
 
 db = Database()
 
@@ -210,9 +213,10 @@ class Address(DbEntity):
 
     treasury_tx_to = Set("TreasuryTx", reverse="to_address")
     """Inverse relation for transactions sent to this address."""
-    # streams_from = Set("Stream", reverse="from_address")
-    # streams_to = Set("Stream", reverse="to_address")
-    # streams = Set("Stream", reverse="contract")
+
+    streams_from = Set("Stream", reverse="from_address")
+    streams_to = Set("Stream", reverse="to_address")
+    streams = Set("Stream", reverse="contract")
     # vesting_escrows = Set("VestingEscrow", reverse="address")
     # vests_received = Set("VestingEscrow", reverse="recipient")
     # vests_funded = Set("VestingEscrow", reverse="funder")
@@ -226,6 +230,10 @@ class Address(DbEntity):
 
     __hash__ = DbEntity.__hash__
 
+    @property
+    def contract(self) -> Contract:
+        return Contract(self.address)
+
     @staticmethod
     @lru_cache(maxsize=None)
     def get_dbid(address: HexAddress) -> int:
@@ -380,7 +388,8 @@ class Token(DbEntity):
 
     address = Required(Address, column="address_id")
     """Foreign key to the address record for this token contract."""
-    # streams = Set('Stream', reverse="token")
+
+    streams = Set("Stream", reverse="token")
     # vesting_escrows = Set("VestingEscrow", reverse="token")
 
     def __eq__(self, other: Union["Token", Address, ChecksumAddress]) -> bool:  # type: ignore [override]
@@ -534,8 +543,10 @@ class TxGroup(DbEntity):
 
     child_txgroups = Set("TxGroup", reverse="parent_txgroup")
     """Set of nested child groups."""
-    # TODO: implement these
-    # streams = Set("Stream", reverse="txgroup")
+
+    streams = Set("Stream", reverse="txgroup")
+
+    # TODO: implement this
     # vesting_escrows = Set("VestingEscrow", reverse="txgroup")
 
     @property
@@ -896,6 +907,151 @@ class TreasuryTx(DbEntity):
             TreasuryTx[treasury_tx_dbid].txgroup = txgroup_dbid
 
 
+_stream_metadata_cache: Final[Dict[HexStr, Tuple[ChecksumAddress, date]]] = {}
+
+
+class Stream(DbEntity):
+    _table_ = "streams"
+    stream_id = PrimaryKey(str)
+
+    contract = Required("Address", reverse="streams")
+    start_block = Required(int)
+    end_block = Optional(int)
+    token = Required("Token", reverse="streams", index=True)
+    from_address = Required("Address", reverse="streams_from")
+    to_address = Required("Address", reverse="streams_to")
+    reason = Optional(str)
+    amount_per_second = Required(Decimal, 38, 1)
+    status = Required(str, default="Active")
+    txgroup = Optional("TxGroup", reverse="streams")
+
+    streamed_funds = Set("StreamedFunds")
+
+    scale = int(1e20)
+
+    @property
+    def is_alive(self) -> bool:
+        if self.end_block is None:
+            assert self.status in ["Active", "Paused"]
+            return self.status == "Active"
+        assert self.status == "Stopped"
+        return False
+
+    @property
+    def amount_per_minute(self) -> int:
+        return self.amount_per_second * 60
+
+    @property
+    def amount_per_hour(self) -> int:
+        return self.amount_per_minute * 60
+
+    @property
+    def amount_per_day(self) -> int:
+        return self.amount_per_hour * 24
+
+    @staticmethod
+    def check_closed(stream_id: HexStr) -> bool:
+        with db_session:
+            return any(sf.is_last_day for sf in Stream[stream_id].streamed_funds)
+
+    @staticmethod
+    def _get_start_and_end(stream_dbid: HexStr) -> Tuple[datetime, datetime]:
+        with db_session:
+            stream = Stream[stream_dbid]
+            start_date, end = stream.start_date, datetime.now(_UTC)
+            # convert start to datetime
+            start = datetime.combine(start_date, time(tzinfo=_UTC), tzinfo=_UTC)
+            if stream.end_block:
+                end = datetime.fromtimestamp(chain[stream.end_block].timestamp, tz=_UTC)
+            return start, end
+
+    def stop_stream(self, block: int) -> None:
+        self.end_block = block
+        self.status = "Stopped"
+
+    def pause(self) -> None:
+        self.status = "Paused"
+
+    @staticmethod
+    def _get_token_and_start_date(stream_id: HexStr) -> Tuple[ChecksumAddress, date]:
+        try:
+            return _stream_metadata_cache[stream_id]
+        except KeyError:
+            with db_session:
+                stream = Stream[stream_id]
+                token = stream.token.address.address
+                start_date = stream.start_date
+            _stream_metadata_cache[stream_id] = token, start_date
+            return token, start_date
+
+    @property
+    def stream_contract(self) -> Contract:
+        return Contract(self.contract.address)
+
+    @property
+    def start_date(self) -> date:
+        return datetime.fromtimestamp(chain[self.start_block].timestamp).date()
+
+    async def amount_withdrawable(self, block: int) -> int:
+        return await self.stream_contract.withdrawable.coroutine(
+            self.from_address.address,
+            self.to_address.address,
+            int(self.amount_per_second),
+            block_identifier=block,
+        )
+
+    def print(self) -> None:
+        symbol = self.token.symbol
+        print(f"{symbol} per second: {self.amount_per_second / self.scale}")
+        print(f"{symbol} per day: {self.amount_per_day / self.scale}")
+
+
+class StreamedFunds(DbEntity):
+    """Each object represents one calendar day of tokens streamed for a particular stream."""
+
+    _table_ = "streamed_funds"
+
+    date = Required(date)
+    stream = Required(Stream, reverse="streamed_funds")
+    PrimaryKey(stream, date)
+
+    amount = Required(Decimal, 38, 18)
+    price = Required(Decimal, 38, 18)
+    value_usd = Required(Decimal, 38, 18)
+    seconds_active = Required(int)
+    is_last_day = Required(bool)
+
+    @db_session
+    def get_entity(stream_id: str, date: datetime) -> "StreamedFunds":
+        stream = Stream[stream_id]
+        return StreamedFunds.get(date=date, stream=stream)
+
+    @classmethod
+    @db_session
+    def create_entity(
+        cls,
+        stream_id: str,
+        date: datetime,
+        price: Decimal,
+        seconds_active: int,
+        is_last_day: bool,
+    ) -> "StreamedFunds":
+        stream = Stream[stream_id]
+        amount_streamed_today = round(
+            stream.amount_per_second * seconds_active / stream.scale, 18
+        )
+        entity = StreamedFunds(
+            date=date,
+            stream=stream,
+            amount=amount_streamed_today,
+            price=round(price, 18),
+            value_usd=round(amount_streamed_today * price, 18),
+            seconds_active=seconds_active,
+            is_last_day=is_last_day,
+        )
+        return entity
+
+
 db.bind(
     provider="sqlite",  # TODO: let user choose postgres with server connection params
     filename=str(SQLITE_DIR / "dao-treasury.sqlite"),
@@ -921,12 +1077,12 @@ def create_stream_ledger_view() -> None:
     Examples:
         >>> create_stream_ledger_view()
     """
+    db.execute("""DROP VIEW IF EXISTS stream_ledger;""")
     db.execute(
         """
-        DROP VIEW IF EXISTS stream_ledger;
         create view stream_ledger as
         SELECT  'Mainnet' as chain_name,
-                cast(DATE AS timestamp) as timestamp,
+                cast(strftime('%s', date || ' 00:00:00') as INTEGER) as timestamp,
                 NULL as block, 
                 NULL as hash, 
                 NULL as log_index, 
@@ -1007,7 +1163,7 @@ def create_general_ledger_view() -> None:
         create VIEW general_ledger as
         select *
         from (
-            SELECT treasury_tx_id, b.chain_name, datetime(a.timestamp, 'unixepoch') AS timestamp, a.block, a.hash, a.log_index, c.symbol AS token, d.address AS "from", d.nickname as from_nickname, e.address AS "to", e.nickname as to_nickname, a.amount, a.price, a.value_usd, f.name AS txgroup, g.name AS parent_txgroup, f.txgroup_id
+            SELECT treasury_tx_id, b.chain_name, a.timestamp, a.block, a.hash, a.log_index, c.symbol AS token, d.address AS "from", d.nickname as from_nickname, e.address AS "to", e.nickname as to_nickname, a.amount, a.price, a.value_usd, f.name AS txgroup, g.name AS parent_txgroup, f.txgroup_id
             FROM treasury_txs a
                 LEFT JOIN chains b ON a.chain = b.chain_dbid
                 LEFT JOIN tokens c ON a.token_id = c.token_id
@@ -1015,9 +1171,9 @@ def create_general_ledger_view() -> None:
                 LEFT JOIN addresses e ON a."to" = e.address_id
                 LEFT JOIN txgroups f ON a.txgroup_id = f.txgroup_id
                 LEFT JOIN txgroups g ON f.parent_txgroup = g.txgroup_id
-            --UNION
-            --SELECT -1, chain_name, TIMESTAMP, cast(block AS integer) block, hash, CAST(log_index AS integer) as log_index, token, "from", from_nickname, "to", to_nickname, amount, price, value_usd, txgroup, parent_txgroup, txgroup_id
-            --FROM stream_ledger
+            UNION
+            SELECT -1, chain_name, timestamp, block, hash, log_index, token, "from", from_nickname, "to", to_nickname, amount, price, value_usd, txgroup, parent_txgroup, txgroup_id
+            FROM stream_ledger
             --UNION
             --SELECT -1, *
             --FROM vesting_ledger
@@ -1093,7 +1249,7 @@ def create_monthly_pnl_view() -> None:
 
 
 with db_session:
-    # create_stream_ledger_view()
+    create_stream_ledger_view()
     # create_vesting_ledger_view()
     create_general_ledger_view()
     create_unsorted_txs_view()

dao_treasury/docker-compose.yaml

@@ -15,6 +15,7 @@ services:
       - GF_SECURITY_ADMIN_USER=${GF_SECURITY_ADMIN_USER:-admin}
       - GF_SECURITY_ADMIN_PASSWORD=${GF_SECURITY_ADMIN_PASSWORD:-admin}
       - GF_AUTH_ANONYMOUS_ENABLED=true
+      - GF_AUTH_ANONYMOUS_ORG_ROLE=Viewer
       - GF_DASHBOARDS_DEFAULT_HOME_DASHBOARD_PATH=/etc/grafana/provisioning/dashboards/summary/Monthly.json
       - GF_SERVER_ROOT_URL
       - GF_RENDERING_SERVER_URL=http://renderer:8091/render

dao_treasury/main.py

@@ -28,6 +28,7 @@ from pathlib import Path
 
 import brownie
 import yaml
+from a_sync import create_task
 from dao_treasury._wallet import load_wallets_from_yaml
 from eth_portfolio_scripts.balances import export_balances
 from eth_typing import BlockNumber
@@ -107,6 +108,11 @@ parser.add_argument(
     help="Port for the DAO Treasury dashboard web interface. Default: 3000",
     default=3000,
 )
+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.",
+)
 parser.add_argument(
     "--renderer-port",
     type=int,
@@ -154,6 +160,7 @@ async def export(args) -> None:
             daemon: Ignored flag.
             grafana_port: Port for Grafana (sets DAO_TREASURY_GRAFANA_PORT).
             renderer_port: Port for renderer (sets DAO_TREASURY_RENDERER_PORT).
+            start_renderer: If True, start renderer; otherwise, only start grafana.
 
     Example:
         In code::
@@ -165,6 +172,8 @@ async def export(args) -> None:
         :func:`dao_treasury._docker.down`,
         :class:`dao_treasury.Treasury.populate_db`
     """
+    import eth_portfolio_scripts.docker
+
     from dao_treasury import _docker, constants, db, Treasury
 
     wallets = getattr(args, "wallet", None)
@@ -195,7 +204,12 @@ async def export(args) -> None:
                 db.Address.set_nickname(address, nickname)
 
     treasury = Treasury(wallets, args.sort_rules, asynchronous=True)
-    _docker.up()
+
+    # Start only the requested containers
+    if args.start_renderer is True:
+        _docker.up()
+    else:
+        _docker.up("grafana")
 
     # eth-portfolio needs this present
     # TODO: we need to update eth-portfolio to honor wallet join and exit times
@@ -209,11 +223,21 @@ async def export(args) -> None:
     # TODO: make this user configurable? would require some dynamic grafana dashboard files
     args.label = "Treasury"
 
-    try:
-        await asyncio.gather(
+    export_task = create_task(
+        asyncio.gather(
             export_balances(args),
             treasury.populate_db(BlockNumber(0), brownie.chain.height),
         )
+    )
+
+    await asyncio.sleep(1)
+
+    # we don't need these containers since dao-treasury uses its own.
+    eth_portfolio_scripts.docker.stop("grafana")
+    eth_portfolio_scripts.docker.stop("renderer")
+
+    try:
+        await export_task
     finally:
         _docker.down()
 

dao_treasury/sorting/__init__.py

@@ -35,6 +35,7 @@ from dao_treasury.sorting.rule import (
     OtherIncomeSortRule,
     RevenueSortRule,
 )
+from dao_treasury.sorting.rules import *
 from dao_treasury.types import TxGroupDbid
 
 

dao_treasury/sorting/rule.py

@@ -31,6 +31,7 @@ See Also:
 
 from collections import defaultdict
 from dataclasses import dataclass
+from logging import getLogger
 from typing import (
     TYPE_CHECKING,
     DefaultDict,
@@ -53,6 +54,9 @@ if TYPE_CHECKING:
     from dao_treasury.db import TreasuryTx
 
 
+logger: Final = getLogger(__name__)
+_log_debug: Final = logger.debug
+
 SORT_RULES: DefaultDict[Type[SortRule], List[SortRule]] = defaultdict(list)
 """Mapping from sort rule classes to lists of instantiated rules, in creation order per class.
 
@@ -214,6 +218,7 @@ class _SortRule:
                 getattr(tx, matcher) == getattr(self, matcher) for matcher in matchers
             )
 
+        _log_debug("checking %s for %s", tx, self.func)
         match = self.func(tx)  # type: ignore [misc]
         return match if isinstance(match, bool) else await match
 

dao_treasury/sorting/rules/__init__.py

@@ -0,0 +1 @@
+from dao_treasury.sorting.rules.ignore import *

dao_treasury/sorting/rules/ignore/__init__.py

@@ -0,0 +1 @@
+from dao_treasury.sorting.rules.ignore.llamapay import *

dao_treasury/sorting/rules/ignore/llamapay.py

@@ -0,0 +1,20 @@
+from dao_treasury import TreasuryTx
+from dao_treasury.sorting.factory import ignore
+from dao_treasury.streams import llamapay
+
+
+@ignore("LlamaPay")
+def is_llamapay_stream_replenishment(tx: TreasuryTx) -> bool:
+    if tx.to_address.address in llamapay.factories:  # type: ignore [operator]
+        # We amortize these streams daily in the `llamapay` module, you'll sort each stream appropriately.
+        return True
+
+    # NOTE: not sure if we want this yet
+    # Puling unused funds back from vesting escrow / llamapay
+    # elif tx.from_address == "Contract: LlamaPay" and "StreamCancelled" in tx.events:
+    #    if tx.amount > 0:
+    #        tx.amount *= -1
+    #    if tx.value_usd > 0:
+    #        tx.value_usd *= -1
+    #    return True
+    return False