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

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev270}/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.dev270}/MIGRATION_4.md

@@ -647,6 +647,7 @@ label values; they do not validate byte widths or address spelling.
 | `MarketId` | an `IporFusionMarkets` member, or `MarketId(n)` |
 | `RoleId` | a `Roles` member (accepted as is), or `RoleId(n)`; `Roles.resolve(name)` returns one |
 | `Decimals`, `Period`, `Amount`, `Shares`, ... | `Decimals(8)`, `Period(0)`, `Amount(n)`, `Shares(n)` |
+| `Wad` | `Wad(6 * 10**17)` (60%): an 18-decimal fraction, `10**18` is 100% |
 | `ChecksumAddress` | `Web3.to_checksum_address(value)` |
 | `HexAddress` | any `ChecksumAddress`, or `parse_hex_address(value)` (20 bytes or `0x`/`0X`-prefixed hex in any case → lowercase `0x` form) |
 | `MorphoBlueMarketId` | `parse_morpho_market_id(value)`: 32 bytes or hex in any spelling, always `0x` + 64 lowercase digits |
@@ -686,6 +687,8 @@ converted amounts `Amount`. A custom `VaultState` annotates the same.
 `PlasmaVault.total_supply()`, `balance_of()` and `get_total_supply_cap()` return
 `Shares` (vault shares), and `transfer` / `approve` / `transfer_from` /
 `set_total_supply_cap` take `Shares`; `ERC20` keeps `Amount`.
+`PlasmaVault.setup_markets_limits` takes `Sequence[tuple[MarketId, Wad]]`: each
+limit is a share of total assets, not an asset amount (see Behavior changes).
 `Reconciliation` amounts (`balance_fuses_total`, `underlying_on_vault`,
 `rewards_manager_balance`, `erc20_direct_total`, `sum`, `on_chain_total_assets`, `delta`,
 `pending_withdrawals`, `implied_market_total`, `market_storage_divergence`) are
@@ -1001,6 +1004,17 @@ and `log_index` was passed through as given (a hex string from a raw log); the e
 These apply to every caller, type-checked or not. Changes described in full above
 are listed with a link.
 
+- **`PlasmaVault.setup_markets_limits` takes WAD shares and validates them.** The
+  contract (`AssetDistributionProtectionLib.MarketLimit.limitInPercentage`) reads each
+  limit as the most of the vault's total assets the market may hold, `10**18` being
+  100%; 3.x typed it as an `Amount` and documented it as an asset amount, so a limit
+  set "in asset units" (`1_000_000` for 1 USDC) became a near-zero share that blocks
+  the market once limits are activated. It now takes `Wad` and raises `ValueError`
+  before building the call for a limit outside `0..10**18`: a negative one is no
+  uint256, and above 100% the vault reverts `MarketLimitSetupInPercentageIsTooHigh`. Pass the share: `Wad(6 * 10**17)` for 60%. Check limits
+  set with 3.x with `PlasmaVault.get_market_limit(market).call(ctx)`, which
+  returns the `Wad` share.
+
 - **The CLI and the MCP tools take the same arguments.**
   - **MCP inputs:** the vault tools' `chain_id` and every `block_number` are
     optional and omitted means auto-detected / latest; `market_morpho_blue` and

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev263
+Version: 4.0.0.dev270
 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.dev270}/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.dev270}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev263"
+version = "4.0.0.dev270"
 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.dev270}/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 (
@@ -333,6 +334,7 @@ from ipor_fusion.types import (
     TokenId,
     TxHash,
     Verdict,
+    Wad,
     format_amount,
     format_shares,
     parse_access_manager_address,
@@ -448,6 +450,7 @@ __all__ = [
     "repository_url",
     "Web3Context",
     "InFlightLimit",
+    "ContextManager",
     "Call",
     "get_logs_adaptive",
     "find_creation_block",
@@ -609,6 +612,7 @@ __all__ = [
     "Liquidity",
     "RoleId",
     "ChainId",
+    "Wad",
     "MorphoBlueMarketId",
     "ProposalHash",
     "TxHash",

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev270}/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.dev270/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.dev270}/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.dev270}/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,12 +26,17 @@ from ipor_fusion.types import (
     Fee,
     FuseAddress,
     MarketId,
+    Period,
     PlasmaVaultAddress,
+    RoleId,
     Shares,
+    Wad,
 )
 
 T = TypeVar("T")
 
+WAD = Wad(10**18)
+
 _BALANCE_FUSE_ADDED_TOPIC = HexBytes(
     Web3.keccak(text="BalanceFuseAdded(uint256,address)")
 )
@@ -355,8 +361,24 @@ class PlasmaVault(ContractWrapper):
             bytes(selector),
         )
 
-    def setup_markets_limits(self, limits: list[tuple[MarketId, Amount]]) -> Call[None]:
-        """ATOMIST-only: set per-market cap in the underlying asset's smallest unit."""
+    def setup_markets_limits(
+        self, limits: Sequence[tuple[MarketId, Wad]]
+    ) -> Call[None]:
+        """Set each market's limit: the most of the vault's total assets the
+        market may hold, as a `Wad` share (``Wad(6 * 10**17)`` is 60%), enforced
+        once `activate_markets_limits` is on (AssetDistributionProtectionLib).
+
+        Raises ``ValueError`` for a limit outside ``0..10**18``: a negative one is
+        no uint256, and the vault reverts ``MarketLimitSetupInPercentageIsTooHigh``
+        above 100%.
+        """
+        for market, limit in limits:
+            if not 0 <= limit <= WAD:
+                raise ValueError(
+                    f"market {market} limit {limit}: expected a WAD share in"
+                    " 0..10**18; above 100% the vault reverts"
+                    " MarketLimitSetupInPercentageIsTooHigh"
+                )
         return self._write("setupMarketsLimits((uint256,uint256)[])", list(limits))
 
     def update_markets_balances(self, market_ids: list[MarketId]) -> Call[None]:
@@ -403,6 +425,163 @@ 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[Wad]:
+        """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;
+        `setup_markets_limits` sets it."""
+        return self._view(
+            "getMarketLimit(uint256)", market, output_types=["uint256"], decoder=Wad
+        )
+
+    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.dev270}/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.dev270}/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)
 

{ipor_fusion-4.0.0.dev263 → ipor_fusion-4.0.0.dev270}/src/ipor_fusion/types.py

@@ -15,6 +15,8 @@ Tick = NewType("Tick", int)
 Liquidity = NewType("Liquidity", int)
 RoleId = NewType("RoleId", int)
 ChainId = NewType("ChainId", int)
+# An 18-decimal fixed-point fraction: 10**18 is 1, i.e. 100% (a market limit).
+Wad = NewType("Wad", int)
 # A Morpho Blue market id (bytes32) in its canonical spelling: "0x" and 64
 # lowercase hex digits, as the Morpho API reports it. Build one with
 # parse_morpho_market_id.