ipor-fusion 4.0.0.dev263__tar.gz → 4.0.0.dev266__tar.gz

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/AGENTS.md

@@ -269,7 +269,7 @@ the lifecycle matrix follows that.
   TypedDict's `__optional_keys__` is right at run time.
   None of them imports `cli/` (`tests/test_sdk_layering.py`)
 - `config/roles.py` — `Roles` IntEnum
-- `core/` — `context` (`Web3Context`), `contract` (`Call`, `ContractWrapper`),
+- `core/` — `context` (`Web3Context`), `context_manager` (`ContextManager`), `contract` (`Call`, `ContractWrapper`),
   `multicall` (`Multicall3`), `logs` (`get_logs_adaptive`: every event scan pages
   `eth_getLogs` within the provider's caps from the contract's creation block, within a
   time and request budget, and raises `LogScanError` rather than return partial logs;

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev263
+Version: 4.0.0.dev266
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py
@@ -442,13 +442,14 @@ Fuse.method()  -->  FuseAction  -->  PlasmaVault.execute([actions])  -->  Call
 |--------|---------|
 | `Web3Context` | Provider connection, signing, tx dispatch, gas estimation |
 | `Call` | Pre-encoded contract call; `.call(ctx)`, `.send(ctx)`, `.calldata`, `.build_transaction(ctx)` |
-| `PlasmaVault` | ERC-4626 vault — execute, deposit, withdraw, fuse and market configuration |
+| `PlasmaVault` | ERC-4626 vault — execute, deposit, withdraw, previews, fuse, market, fee and limit configuration |
 | `VaultSimulator` | Batch `execute` + reads through `eth_simulateV1`, multi-block, no local node |
 | `FusionFactory` | Deploy a new vault (`clone`, `clone_supervised`) |
 | `AccessManager` | Role-based access control |
 | `RewardsManager` | Claim and vest rewards |
 | `WithdrawManager` | Time-windowed withdrawal requests |
-| `FeeManager` | Deposit, performance, and management fee configuration |
+| `FeeManager` | Deposit, performance, and management fee configuration and harvesting |
+| `ContextManager` | Run calls on approved context-aware targets on the caller's behalf |
 | `FeeAccount` | Fee escrow account, resolves its `FeeManager` |
 | `PriceOracleMiddleware` | Asset price feeds |
 | `PriceOracleMiddlewareManager` | Per-vault price-source overrides |

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/README.md

@@ -394,13 +394,14 @@ Fuse.method()  -->  FuseAction  -->  PlasmaVault.execute([actions])  -->  Call
 |--------|---------|
 | `Web3Context` | Provider connection, signing, tx dispatch, gas estimation |
 | `Call` | Pre-encoded contract call; `.call(ctx)`, `.send(ctx)`, `.calldata`, `.build_transaction(ctx)` |
-| `PlasmaVault` | ERC-4626 vault — execute, deposit, withdraw, fuse and market configuration |
+| `PlasmaVault` | ERC-4626 vault — execute, deposit, withdraw, previews, fuse, market, fee and limit configuration |
 | `VaultSimulator` | Batch `execute` + reads through `eth_simulateV1`, multi-block, no local node |
 | `FusionFactory` | Deploy a new vault (`clone`, `clone_supervised`) |
 | `AccessManager` | Role-based access control |
 | `RewardsManager` | Claim and vest rewards |
 | `WithdrawManager` | Time-windowed withdrawal requests |
-| `FeeManager` | Deposit, performance, and management fee configuration |
+| `FeeManager` | Deposit, performance, and management fee configuration and harvesting |
+| `ContextManager` | Run calls on approved context-aware targets on the caller's behalf |
 | `FeeAccount` | Fee escrow account, resolves its `FeeManager` |
 | `PriceOracleMiddleware` | Asset price feeds |
 | `PriceOracleMiddlewareManager` | Per-vault price-source overrides |

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev263"
+version = "4.0.0.dev266"
 description = "The IPOR Fusion SDK for Python"
 authors = [
     { name = "Adam Mydlarz", email = "amydlarz@gmail.com" },

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/__init__.py

@@ -36,6 +36,7 @@ from ipor_fusion.core.access import (
     role_account_sort_key,
 )
 from ipor_fusion.core.context import InFlightLimit, Web3Context
+from ipor_fusion.core.context_manager import ContextManager
 from ipor_fusion.core.contract import Call
 from ipor_fusion.core.erc20 import ERC20
 from ipor_fusion.core.external_state_executor import (
@@ -448,6 +449,7 @@ __all__ = [
     "repository_url",
     "Web3Context",
     "InFlightLimit",
+    "ContextManager",
     "Call",
     "get_logs_adaptive",
     "find_creation_block",

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/core/__init__.py

@@ -10,6 +10,7 @@ from ipor_fusion.core.access import (
     role_account_sort_key,
 )
 from ipor_fusion.core.context import InFlightLimit, Web3Context
+from ipor_fusion.core.context_manager import ContextManager
 from ipor_fusion.core.contract import (
     Call,
 )
@@ -85,6 +86,7 @@ from ipor_fusion.core.withdraw_manager import (
 __all__ = [
     "Web3Context",
     "InFlightLimit",
+    "ContextManager",
     "Multicall3",
     "Multicall3Batch",
     "BatchValue",

ipor_fusion-4.0.0.dev266/src/ipor_fusion/core/context_manager.py

@@ -0,0 +1,55 @@
+"""IPOR Fusion ContextManager: runs calls on context-aware targets (the vault's
+managers and fuses) on behalf of the caller."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from eth_typing import ChecksumAddress
+from web3 import Web3
+
+from ipor_fusion.core.contract import Call, ContractWrapper
+
+
+def _address_list_decoder(value: tuple[str, ...]) -> list[ChecksumAddress]:
+    return [Web3.to_checksum_address(item) for item in value]
+
+
+class ContextManager(ContractWrapper):
+    """Runs each ``(target, data)`` call with the caller set as the target's
+    context sender, so a contract that reads the context acts for the caller.
+    Only approved targets can be called."""
+
+    def get_approved_targets(self) -> Call[list[ChecksumAddress]]:
+        return self._view(
+            "getApprovedTargets()",
+            output_types=["address[]"],
+            decoder=_address_list_decoder,
+        )
+
+    def is_target_approved(self, target: ChecksumAddress) -> Call[bool]:
+        return self._view(
+            "isTargetApproved(address)", target, output_types=["bool"], decoder=bool
+        )
+
+    def get_nonce(self, sender: ChecksumAddress) -> Call[int]:
+        """The last nonce ``sender`` used in a signed context call; the next
+        signed call must carry a higher one."""
+        return self._view(
+            "getNonce(address)", sender, output_types=["uint256"], decoder=int
+        )
+
+    def add_approved_targets(self, targets: Sequence[ChecksumAddress]) -> Call[None]:
+        return self._write("addApprovedTargets(address[])", list(targets))
+
+    def remove_approved_targets(self, targets: Sequence[ChecksumAddress]) -> Call[None]:
+        return self._write("removeApprovedTargets(address[])", list(targets))
+
+    def run_with_context(
+        self, calls: Sequence[tuple[ChecksumAddress, bytes]]
+    ) -> Call[None]:
+        """Run ``calls`` in order, atomically; every target must be approved."""
+        return self._write(
+            "runWithContext((address[],bytes[]))",
+            ([target for target, _ in calls], [data for _, data in calls]),
+        )

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/core/fee_manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 
 from eth_typing import ChecksumAddress
@@ -7,7 +8,7 @@ from web3 import Web3
 from web3.types import Timestamp
 
 from ipor_fusion.core.contract import Call, ContractWrapper
-from ipor_fusion.types import Fee, Period
+from ipor_fusion.types import Fee, Period, Shares
 
 
 @dataclass(slots=True)
@@ -79,6 +80,64 @@ class FeeManager(ContractWrapper):
     (10000 = 100%).
     """
 
+    def harvest_all_fees(self) -> Call[None]:
+        """Distribute the collected management and performance fees to their
+        recipients (public)."""
+        return self._write("harvestAllFees()")
+
+    def harvest_management_fee(self) -> Call[None]:
+        return self._write("harvestManagementFee()")
+
+    def harvest_performance_fee(self) -> Call[None]:
+        return self._write("harvestPerformanceFee()")
+
+    def update_management_fee(self, recipients: Sequence[RecipientFee]) -> Call[None]:
+        """Replace the management fee recipients; each ``fee_value`` in percent
+        with 2 decimals (10000 = 100%)."""
+        return self._write(
+            "updateManagementFee((address,uint256)[])",
+            [(r.recipient, r.fee_value) for r in recipients],
+        )
+
+    def update_performance_fee(self, recipients: Sequence[RecipientFee]) -> Call[None]:
+        """Replace the performance fee recipients; each ``fee_value`` in percent
+        with 2 decimals (10000 = 100%)."""
+        return self._write(
+            "updatePerformanceFee((address,uint256)[])",
+            [(r.recipient, r.fee_value) for r in recipients],
+        )
+
+    def set_ipor_dao_fee_recipient_address(
+        self, recipient: ChecksumAddress
+    ) -> Call[None]:
+        return self._write("setIporDaoFeeRecipientAddress(address)", recipient)
+
+    def set_deposit_fee(self, fee: Fee) -> Call[None]:
+        """WAD (``10**18`` is 100%), as `get_deposit_fee` reports it."""
+        return self._write("setDepositFee(uint256)", fee)
+
+    def update_high_water_mark_performance_fee(self) -> Call[None]:
+        """Reset the high-water mark to the current exchange rate."""
+        return self._write("updateHighWaterMarkPerformanceFee()")
+
+    def update_interval_high_water_mark_performance_fee(
+        self, interval: Period
+    ) -> Call[None]:
+        """The least time between automatic high-water-mark resets; zero
+        disables them."""
+        return self._write(
+            "updateIntervalHighWaterMarkPerformanceFee(uint32)", interval
+        )
+
+    def calculate_deposit_fee(self, shares: Shares) -> Call[Shares]:
+        """The fee part, in shares, of a deposit minting ``shares``."""
+        return self._view(
+            "calculateDepositFee(uint256)",
+            shares,
+            output_types=["uint256"],
+            decoder=Shares,
+        )
+
     def get_deposit_fee(self) -> Call[Fee]:
         """WAD (1e18 = 100%). Reverts on FeeManager deployments predating
         the deposit fee - callers should treat a revert as no-deposit-fee."""

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/core/plasma_vault.py

@@ -13,6 +13,7 @@ from web3 import Web3
 from web3.exceptions import ContractLogicError
 from web3.types import LogReceipt, Timestamp
 
+from ipor_fusion.config.roles import Roles
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.contract import Call, ContractWrapper
 from ipor_fusion.core.fuse_action import FuseAction
@@ -25,7 +26,9 @@ from ipor_fusion.types import (
     Fee,
     FuseAddress,
     MarketId,
+    Period,
     PlasmaVaultAddress,
+    RoleId,
     Shares,
 )
 
@@ -403,6 +406,162 @@ class PlasmaVault(ContractWrapper):
             "maxWithdraw(address)", account, output_types=["uint256"], decoder=Amount
         )
 
+    def max_redeem(self, account: ChecksumAddress) -> Call[Shares]:
+        return self._view(
+            "maxRedeem(address)", account, output_types=["uint256"], decoder=Shares
+        )
+
+    def max_deposit(self, receiver: ChecksumAddress) -> Call[Amount]:
+        """Assets ``receiver`` can still deposit under the total supply cap."""
+        return self._view(
+            "maxDeposit(address)", receiver, output_types=["uint256"], decoder=Amount
+        )
+
+    def max_mint(self, receiver: ChecksumAddress) -> Call[Shares]:
+        """Shares ``receiver`` can still mint under the total supply cap."""
+        return self._view(
+            "maxMint(address)", receiver, output_types=["uint256"], decoder=Shares
+        )
+
+    def preview_deposit(self, assets: Amount) -> Call[Shares]:
+        """Shares a deposit of ``assets`` mints, after the deposit fee."""
+        return self._view(
+            "previewDeposit(uint256)", assets, output_types=["uint256"], decoder=Shares
+        )
+
+    def preview_mint(self, shares: Shares) -> Call[Amount]:
+        """Assets a mint of ``shares`` takes, the deposit fee included."""
+        return self._view(
+            "previewMint(uint256)", shares, output_types=["uint256"], decoder=Amount
+        )
+
+    def preview_withdraw(self, assets: Amount) -> Call[Shares]:
+        """Shares an instant withdrawal of ``assets`` burns, the withdraw fee
+        included."""
+        return self._view(
+            "previewWithdraw(uint256)", assets, output_types=["uint256"], decoder=Shares
+        )
+
+    def preview_redeem(self, shares: Shares) -> Call[Amount]:
+        """Assets an instant redemption of ``shares`` pays, after the withdraw fee."""
+        return self._view(
+            "previewRedeem(uint256)", shares, output_types=["uint256"], decoder=Amount
+        )
+
+    def deposit_with_permit(
+        self,
+        assets: Amount,
+        receiver: ChecksumAddress,
+        deadline: Timestamp,
+        v: int,
+        r: bytes,
+        s: bytes,
+    ) -> Call[None]:
+        """`deposit` with an EIP-2612 permit of the asset signed by the caller.
+        The vault deposits even when the permit call fails (an allowance already
+        in place, or a front-run permit)."""
+        return self._write(
+            "depositWithPermit(uint256,address,uint256,uint8,bytes32,bytes32)",
+            assets,
+            receiver,
+            deadline,
+            v,
+            r,
+            s,
+        )
+
+    def is_fuse_supported(self, fuse: FuseAddress) -> Call[bool]:
+        """Whether ``fuse`` is registered (`add_fuses`), so `execute` may call it."""
+        return self._view(
+            "isFuseSupported(address)", fuse, output_types=["bool"], decoder=bool
+        )
+
+    def is_balance_fuse_supported(
+        self, market: MarketId, fuse: FuseAddress
+    ) -> Call[bool]:
+        """Whether ``fuse`` is the balance fuse of ``market``."""
+        return self._view(
+            "isBalanceFuseSupported(uint256,address)",
+            market,
+            fuse,
+            output_types=["bool"],
+            decoder=bool,
+        )
+
+    def is_market_substrate_granted(
+        self, market: MarketId, substrate: bytes
+    ) -> Call[bool]:
+        """Whether the 32-byte ``substrate`` is granted on ``market``."""
+        if len(substrate) != 32:
+            raise ValueError(f"substrate must be 32 bytes, got {len(substrate)}")
+        return self._view(
+            "isMarketSubstrateGranted(uint256,bytes32)",
+            market,
+            substrate,
+            output_types=["bool"],
+            decoder=bool,
+        )
+
+    def is_markets_limits_activated(self) -> Call[bool]:
+        return self._view(
+            "isMarketsLimitsActivated()", output_types=["bool"], decoder=bool
+        )
+
+    def get_market_limit(self, market: MarketId) -> Call[int]:
+        """The most of the vault's total assets ``market`` may hold, as a WAD
+        share (``10**18`` is 100%), enforced only while limits are activated."""
+        return self._view(
+            "getMarketLimit(uint256)", market, output_types=["uint256"], decoder=int
+        )
+
+    def activate_markets_limits(self) -> Call[None]:
+        return self._write("activateMarketsLimits()")
+
+    def deactivate_markets_limits(self) -> Call[None]:
+        return self._write("deactivateMarketsLimits()")
+
+    def set_price_oracle_middleware(self, middleware: ChecksumAddress) -> Call[None]:
+        """The vault rejects a middleware whose quote currency differs from the
+        current one."""
+        return self._write("setPriceOracleMiddleware(address)", middleware)
+
+    def configure_performance_fee(
+        self, fee_account: ChecksumAddress, fee: Fee
+    ) -> Call[None]:
+        """``fee`` in percent with 2 decimals (10000 = 100%), as
+        `get_performance_fee_data` reports it."""
+        return self._write("configurePerformanceFee(address,uint256)", fee_account, fee)
+
+    def configure_management_fee(
+        self, fee_account: ChecksumAddress, fee: Fee
+    ) -> Call[None]:
+        """``fee`` in percent with 2 decimals (10000 = 100%), as
+        `get_management_fee_data` reports it."""
+        return self._write("configureManagementFee(address,uint256)", fee_account, fee)
+
+    def set_rewards_claim_manager_address(
+        self, rewards_claim_manager: ChecksumAddress
+    ) -> Call[None]:
+        return self._write(
+            "setRewardsClaimManagerAddress(address)", rewards_claim_manager
+        )
+
+    def enable_transfer_shares(self) -> Call[None]:
+        """Make share `transfer` and `transferFrom` public (PUBLIC_ROLE on both
+        selectors); only an access manager admin can map them back."""
+        return self._write("enableTransferShares()")
+
+    def set_minimal_execution_delays_for_roles(
+        self, delays: Sequence[tuple[RoleId | Roles, Period]]
+    ) -> Call[None]:
+        """The floor of each role's execution delay; the access manager refuses
+        to grant the role with a shorter one."""
+        return self._write(
+            "setMinimalExecutionDelaysForRoles(uint64[],uint256[])",
+            [role for role, _ in delays],
+            [delay for _, delay in delays],
+        )
+
     def convert_to_shares(self, amount: Amount) -> Call[Shares]:
         return self._view(
             "convertToShares(uint256)",

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/core/rewards_manager.py

@@ -7,7 +7,7 @@ from web3.types import Timestamp
 
 from ipor_fusion.core.contract import Call, ContractWrapper
 from ipor_fusion.core.fuse_action import FuseAction
-from ipor_fusion.types import Amount, FuseAddress
+from ipor_fusion.types import Amount, FuseAddress, Period
 
 
 @dataclass(slots=True)
@@ -76,3 +76,16 @@ class RewardsManager(ContractWrapper):
 
     def update_balance(self) -> Call[None]:
         return self._write("updateBalance()")
+
+    def transfer_vested_tokens_to_vault(self) -> Call[None]:
+        """Move the vested part (`balance_of`) to the vault; a no-op at zero."""
+        return self._write("transferVestedTokensToVault()")
+
+    def remove_reward_fuses(self, fuses: Sequence[FuseAddress]) -> Call[None]:
+        return self._write("removeRewardFuses(address[])", fuses)
+
+    def setup_vesting_time(self, vesting_time: Period) -> Call[None]:
+        """The vesting duration of claimed rewards. Mid-vesting it reverts
+        ``UnsafeVestingTime`` when the new duration would vest less than was
+        already transferred; `update_balance` first resets the curve."""
+        return self._write("setupVestingTime(uint256)", vesting_time)

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev266}/src/ipor_fusion/core/withdraw_manager.py

@@ -72,6 +72,15 @@ class WithdrawManager(ContractWrapper):
     def update_withdraw_window(self, window: Period) -> Call[None]:
         return self._write("updateWithdrawWindow(uint256)", window)
 
+    def update_withdraw_fee(self, fee: Fee) -> Call[None]:
+        """The instant-exit fee, WAD (``10**18`` is 100%, above it reverts)."""
+        return self._write("updateWithdrawFee(uint256)", fee)
+
+    def update_request_fee(self, fee: Fee) -> Call[None]:
+        """The scheduled-exit fee charged on `request_shares`, WAD (``10**18``
+        is 100%, above it reverts)."""
+        return self._write("updateRequestFee(uint256)", fee)
+
     def update_plasma_vault_address(self, vault: PlasmaVaultAddress) -> Call[None]:
         return self._write("updatePlasmaVaultAddress(address)", vault)