ipor-fusion 4.0.0.dev86__tar.gz → 4.0.0.dev88__tar.gz

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/AGENTS.md

@@ -218,12 +218,14 @@ the lifecycle matrix follows that.
   `simulation` (`VaultSimulator`, eth_simulateV1, `erc20_balance_slot` and ERC-20 balance
   overrides), `oracle`, `fusion_factory`,
   `external_state_executor` (NAV marks for market 50), `erc20`, `fuse_action`
-  (`FuseAction`), `address` (`_validate_not_zero_address`). `core` imports neither
+  (`FuseAction`), `fuse` (the `Fuse` base, `StakeFuse`, the shared validators and
+  substrate packers), `address` (`_validate_not_zero_address`). `core` imports neither
   `fuses` nor `crosschain` (`tests/test_sdk_layering.py`)
 - `fuses/` — per-protocol fuse encoders (aave_v3, async_action, compound_v3, crosschain/,
   erc4626, euler_v2, external_state, fluid_instadapp, gearbox_v3, merkl, morpho, ramses_v2,
-  uniswap_v3, universal, `events.py`); `base.py` holds `Fuse` and the
-  shared validators and re-exports `FuseAction` and `ZERO_ADDRESS` (from `types`)
+  uniswap_v3, universal, `events.py`); `base.py` re-exports the `core/fuse.py` base and validators,
+  `FuseAction` and `ZERO_ADDRESS` (from `types`). A fuse is a value: equality and
+  hash cover its class and every attribute it stores
 - `crosschain/` — crosschain Plasma Vaults (executor on the hub chain, dispatcher at
   the same address on each spoke chain), split like the contracts: shared `messages`
   (`Command`, `MsgType`, envelopes), `contracts` (wrapper bases), `transport`
@@ -276,7 +278,9 @@ or examples.
 - `Call[T]` (`core/contract.py`): every `ContractWrapper` method (one per
   Solidity function) returns a `Call` instead of executing. `.call()` runs
   `eth_call` and decodes to `T`; `.send()` signs and submits, returning a
-  `TxReceipt`; `.calldata` hands the bytes to an external signer;
+  `TxReceipt`; `.calldata` hands the bytes to an external signer (a wrapper
+  built with `ctx=None`, e.g. `PlasmaVault(None, address)`, builds calldata
+  offline; there is no separate encoder factory);
   `.build_transaction()` / `Web3Context.estimate_gas` preview without signing.
   A `Call` without `output_types` (a write) raises on `.call()`. The same
   `Call` feeds `VaultSimulator.observe`, so reads, sends and simulations share

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/MIGRATION_4.md

@@ -93,7 +93,7 @@ The Uniswap V3 / Ramses V2 position events' `version`, `sender` and `recipient`
 `quote_ccip_native_fee(block=)` and `OracleMappingReader.asset_source_events` take a
 `BlockIdentifier`.
 
-**Address roles.** `PlasmaVault(ctx, address)`, `PlasmaVault.encoder(address)`,
+**Address roles.** `PlasmaVault(ctx, address)` (`ctx` may be `None`, see below),
 `validate_vault`, `fetch_deployment_info`, the HyperCore, lending-health and
 oracle-mapping readers, `read_external_state`, `VaultSimulator(vault=)`,
 `CrosschainSimulator`, crosschain discovery, the hub-manager inputs
@@ -194,6 +194,35 @@ are `ProposalHash`; `ExternalStateEvent.transaction_hash` is a `TxHash`.
 except below): `chain_id` fields are `ChainId`, `role_id` `RoleId`, `market_id`
 `MarketId`. Calling an MCP tool function directly from Python takes `ChainId`.
 
+**Offline wrappers.** `ContractWrapper.encoder()` (and the `PlasmaVault` /
+`AccessManager` overrides) is gone. Every wrapper constructor takes
+`ctx: Web3Context | None`, so build an offline wrapper with the normal
+constructor and an address: `PlasmaVault(None, vault)`, `ERC20(None, token)`,
+`FusionFactory(None, factory)`, `LegacyPriceOracleMiddleware(None, oracle,
+Decimals(8))`. The address is required (there is no zero-address placeholder) and
+subclass parameters stay required, so the wrapper is fully initialized:
+`.encoder()` skipped the constructor, and a legacy oracle built that way failed to
+decode `get_asset_price`. `.calldata` still needs no context; `.call()`, `.send()`,
+`.build_transaction()` and `.estimate_gas()` raise `ValueError` until one is passed
+to them, and a method that reads the chain itself (log scans such as
+`get_balance_fuses` or `get_pending_requests`, `withdraw_manager_address`,
+`Multicall3.aggregate` / `try_aggregate`, the Aave V3 and Morpho position reads)
+raises `ValueError("Web3Context required: <wrapper> at <address> ...")` instead of
+an `AttributeError` on `None`. `ExternalStateExecutor` still refuses the zero
+address for its hash and event readers.
+
+| 3.x | 4.0 |
+|---|---|
+| `PlasmaVault.encoder(vault)` | `PlasmaVault(None, vault)` |
+| `ERC20.encoder()` (no address) | `ERC20(None, token)`: pass the real address |
+| `Cls.__new__(Cls)` + `_ctx` / `_address` | `Cls(None, address)` |
+
+**Fuse base.** `Fuse`, `StakeFuse` and the shared validators and substrate packers
+live in `ipor_fusion.core.fuse`; `ipor_fusion.fuses.base`, `ipor_fusion.fuses` and
+`ipor_fusion` re-export them, so existing imports keep working. Fuse equality and
+hash now cover every attribute a fuse stores, not only its class and address (see
+[Behavior changes](#behavior-changes)).
+
 **Moved, still importable.** `FuseAction` lives in `ipor_fusion.core.fuse_action` and
 `ZERO_ADDRESS` in `ipor_fusion.types`; both are re-exported from
 `ipor_fusion.fuses.base` and `FuseAction` from `ipor_fusion`. The CLI's internal
@@ -202,6 +231,12 @@ except below): `chain_id` fields are `ChainId`, `role_id` `RoleId`, `market_id`
 
 ## Behavior changes
 
+- Two fuses are equal (and hash alike) only when they have the same class and the
+  same stored state. `StakeFuse` subclasses (`GearboxStakeFuse`,
+  `FluidInstadappStakingFuse`) with the same fuse address but different
+  `staking_address` were equal and collapsed in a set or dict key; they are now
+  distinct. A custom `Fuse` subclass is compared on its instance attributes, which
+  must be hashable; drop an `__eq__` / `__hash__` override that only added them.
 - The MCP `vault_info` document reports the vault address checksummed (the CLI
   already did).
 - `SubstrateInfo.address` is `None` instead of `""` for a substrate without an

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev86
+Version: 4.0.0.dev88
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/examples/advanced_euler_v2_credit_market_base.py

@@ -261,12 +261,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def market_substrates() -> list[bytes]:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/examples/advanced_euler_v2_looping_arbitrum.py

@@ -208,7 +208,7 @@ def clone_args() -> dict:
 
 
 def unsigned_clone_calldata() -> bytes:
-    return FusionFactory.encoder(ARBITRUM_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, ARBITRUM_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def euler_market_substrates() -> list[bytes]:
@@ -260,7 +260,7 @@ def enable_euler_actions() -> list[FuseAction]:
 def build_swap_action() -> FuseAction:
     """Swap the borrowed USDC through Uniswap V3 and require flash repayment."""
     transfer_data = (
-        ERC20.encoder(ARBITRUM_USDC)
+        ERC20(None, ARBITRUM_USDC)
         .transfer(UNISWAP_UNIVERSAL_ROUTER, BORROW_USDC)
         .calldata
     )

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/examples/external_state_margin_leg_base.py

@@ -438,12 +438,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def market_substrates() -> list[bytes]:
@@ -534,9 +534,9 @@ def market_substrates() -> list[bytes]:
 def venue_transfer_calldata(amount: Amount) -> bytes:
     """``USDC.transfer(VENUE_DEPOSIT_ADDRESS, amount)`` calldata, run from the executor.
 
-    Encoded with a ctx-less ERC20 wrapper -- pure bytes, no chain access.
+    Encoded with an ERC20 wrapper built with ctx=None -- pure bytes, no chain access.
     """
-    return ERC20.encoder(BASE_USDC).transfer(VENUE_DEPOSIT_ADDRESS, amount).calldata
+    return ERC20(None, BASE_USDC).transfer(VENUE_DEPOSIT_ADDRESS, amount).calldata
 
 
 def build_enter_action(amount: Amount) -> FuseAction:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/examples/simple_aave_v3_supply_base.py

@@ -201,12 +201,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def build_supply_action(amount: Amount) -> FuseAction:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/pyproject.toml

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

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/access.py

@@ -1,6 +1,5 @@
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Self
 
 from eth_abi import decode
 from eth_abi.exceptions import InsufficientDataBytes
@@ -68,17 +67,13 @@ def _role_status_decoder(values: tuple) -> RoleStatus:
 class AccessManager(ContractWrapper):
     """Manages role-based access control for PlasmaVault operations."""
 
-    def __init__(self, ctx: Web3Context, address: AccessManagerAddress):
+    def __init__(self, ctx: Web3Context | None, address: AccessManagerAddress):
         super().__init__(ctx, address)
 
     @property
     def address(self) -> AccessManagerAddress:
         return AccessManagerAddress(self._address)
 
-    @classmethod
-    def encoder(cls, address: AccessManagerAddress | None = None) -> Self:  # type: ignore[override]
-        return super().encoder(address)
-
     def grant_role(
         self, role_id: RoleId | Roles, account: ChecksumAddress, execution_delay: Period
     ) -> Call[None]:
@@ -161,7 +156,7 @@ class AccessManager(ContractWrapper):
             if predicate(role_id, account):
                 candidates[(role_id, account)] = None
 
-        statuses = Multicall3(self._ctx).aggregate(
+        statuses = Multicall3(self._require_ctx()).aggregate(
             [self.has_role(role_id, account) for role_id, account in candidates]
         )
         return [
@@ -180,7 +175,7 @@ class AccessManager(ContractWrapper):
             Web3.keccak(text="RoleGranted(uint64,address,uint32,uint48,bool)")
         ).to_0x_hex()
         return list(
-            self._ctx.get_logs(
+            self._require_ctx().get_logs(
                 contract_address=self._address, topics=[event_signature_hash]
             )
         )

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/contract.py

@@ -129,18 +129,19 @@ class Call(Generic[T]):
         return actual
 
 
-_ENCODER_PLACEHOLDER_ADDRESS: ChecksumAddress = cast(
-    ChecksumAddress, "0x0000000000000000000000000000000000000000"
-)
-
-
 class ContractWrapper:
     """Base wrapper. Subclasses expose one method per Solidity function that
     returns a `Call[T]` — never executing eagerly. Callers chain `.call()` for
     reads, `.send()` for writes, or hand the `Call` to `VaultSimulator`.
+
+    `ctx` may be ``None`` for offline use, e.g. external-signer flows (HTTP
+    signing service, multisig) that only need `Call.calldata`: every builder
+    works, and `.call()` / `.send()` on its Calls raise until a context is
+    passed to them. Methods that read the chain themselves (log scans, storage
+    reads, batched reads) raise `ValueError` on such a wrapper.
     """
 
-    def __init__(self, ctx: Web3Context, address: ChecksumAddress):
+    def __init__(self, ctx: Web3Context | None, address: ChecksumAddress):
         self._ctx = ctx
         self._address = Web3.to_checksum_address(address)
 
@@ -148,30 +149,13 @@ class ContractWrapper:
     def address(self) -> ChecksumAddress:
         return self._address
 
-    @classmethod
-    def encoder(cls, address: ChecksumAddress | None = None):
-        """Build a ctx-less wrapper: every builder method, no Web3Context.
-
-        Named for its first use, external-signer flows (HTTP signing service,
-        multisig), which only need `Call.calldata` — the actual `to` and `ctx`
-        are filled in by the signer. It serves any builder that needs no chain
-        access, decoders included. Calling `.call()` or `.send()` on a Call
-        produced this way raises (no ctx).
-
-        Pass `address` unless `.calldata` really is the only consumer. The
-        encoding ignores it, but a builder that reads `self._address`
-        semantically — matching it against a log's emitter, say, or folding it
-        into a hash — runs against the placeholder zero address without one,
-        and so rejects input that is genuinely the caller's.
-        """
-        instance = cls.__new__(cls)
-        instance._ctx = None
-        instance._address = (
-            Web3.to_checksum_address(address)
-            if address is not None
-            else _ENCODER_PLACEHOLDER_ADDRESS
-        )
-        return instance
+    def _require_ctx(self) -> Web3Context:
+        if self._ctx is None:
+            raise ValueError(
+                f"Web3Context required: {type(self).__name__} at {self._address} "
+                "was built without one (ctx=None), which only builds calldata."
+            )
+        return self._ctx
 
     def _view(
         self,

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/external_state_executor.py

@@ -463,13 +463,13 @@ class ExternalStateExecutor(ContractWrapper):
         The hash is bound to a chain. `chain_id` defaults to this wrapper's
         context; pass it explicitly when the context that executes the call is
         not the one the wrapper was built with (`Call.call(other_ctx)`), or to
-        read through a ctx-less `encoder()` instance.
+        read through a wrapper built with `ctx=None`.
         """
         account = Web3.to_checksum_address(balance_account)
 
         def to_proposal(values: tuple[int, str, int, int]) -> BalanceProposal | None:
             # Both hash inputs first, before the empty-slot return. Resolved
-            # inside the decoder so a calldata-only `encoder()` wrapper keeps
+            # inside the decoder so a calldata-only (`ctx=None`) wrapper keeps
             # working like every sibling, but ahead of the sentinel so a
             # misconfigured poller fails on its first read rather than on the
             # first read that happens to find a proposal.
@@ -504,29 +504,28 @@ class ExternalStateExecutor(ContractWrapper):
         )
 
     def _require_address(self) -> ChecksumAddress:
-        """This executor's address, or a clear error on an address-less
-        `encoder()`.
+        """This executor's address, or a clear error for the zero address.
 
-        The other half of the hash's binding, and the placeholder zero address
-        is not a usable stand-in for it: it stamps a hash bound to no contract,
+        The other half of the hash's binding, and the zero address is not a
+        usable stand-in for it: it stamps a hash bound to no contract,
         and it matches only a log claiming to come from none."""
         if self._address == ZERO_ADDRESS:
             raise ValueError(
                 "executor address required: the proposal hash binds it and the "
                 "event readers match it against a log's emitter, so build this "
-                "wrapper with an address rather than a bare encoder()."
+                "wrapper with the executor's address, not the zero address."
             )
         return self._address
 
     def _require_chain_id(self, override: ChainId | None = None) -> ChainId:
         """`override` if the caller named one, else the wrapper's chain, else a
-        clear error on a ctx-less `encoder()`."""
+        clear error on a wrapper built with `ctx=None`."""
         if override is not None:
             return override
         if self._ctx is None:
             raise ValueError(
                 "Web3Context required: the proposal hash is bound to a chain id, "
-                "so build this wrapper with a ctx rather than via encoder(), "
+                "so build this wrapper with a ctx rather than ctx=None, "
                 "or pass chain_id= to this method."
             )
         return self._ctx.chain_id
@@ -673,7 +672,7 @@ class ExternalStateExecutor(ContractWrapper):
 
         The hash is bound to a chain. `chain_id` defaults to this wrapper's
         context; a caller with no context -- decoding indexer or `get_logs`
-        rows -- reaches this through `encoder(address)` and passes `chain_id`
+        rows -- builds it with `ExternalStateExecutor(None, address)` and passes `chain_id`
         explicitly. Either way the whole path is pure, with no RPC.
 
         `find_balance_proposed` applies the same emitter check while scanning.
@@ -755,7 +754,7 @@ class ExternalStateExecutor(ContractWrapper):
 
         The hash is bound to a chain. `chain_id` defaults to this wrapper's
         context; pass it explicitly to verify against a different chain, or to
-        scan through a ctx-less `encoder()` instance.
+        scan through a wrapper built with `ctx=None`.
 
         Over a `get_logs` range this still answers a different question than
         `pending_proposals`: a proposal may have been confirmed since, which

ipor_fusion-4.0.0.dev86/src/ipor_fusion/fuses/base.py → ipor_fusion-4.0.0.dev88/src/ipor_fusion/core/fuse.py

@@ -1,3 +1,11 @@
+"""The fuse encoder base: `Fuse`, `StakeFuse` and the shared validators and
+substrate packers.
+
+It lives in ``core`` so encoders outside ``ipor_fusion.fuses`` can build on it
+without importing that package, whose ``__init__`` loads every encoder.
+``ipor_fusion.fuses.base`` re-exports all of it.
+"""
+
 from abc import ABC
 
 from eth_abi import encode
@@ -8,11 +16,16 @@ from ipor_fusion.core.address import _validate_not_zero_address
 from ipor_fusion.core.contract import _parse_param_types
 from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.types import MAX_UINT256, Amount, FuseAddress
-from ipor_fusion.types import ZERO_ADDRESS as ZERO_ADDRESS
 
 
 class Fuse(ABC):  # noqa: B024  # ABC marks intent; no shared abstract method
-    """Abstract base class for all protocol fuse adapters."""
+    """Abstract base class for all protocol fuse adapters.
+
+    A fuse is a value: two fuses are equal (and hash alike) when they are of the
+    same class and carry the same constructor state (the fuse address, plus e.g.
+    a `StakeFuse`'s staking contract), so a subclass that stores more state is
+    compared on it without overriding anything. That state must be hashable.
+    """
 
     def __init__(self, address: FuseAddress):
         _validate_not_zero_address(address, "fuse address")
@@ -42,14 +55,10 @@ class Fuse(ABC):  # noqa: B024  # ABC marks intent; no shared abstract method
             raise ValueError(f"{name} must not be negative, got {value}")
 
     def __eq__(self, other: object) -> bool:
-        return (
-            isinstance(other, Fuse)
-            and type(self) is type(other)
-            and self._address == other._address
-        )
+        return type(self) is type(other) and vars(self) == vars(other)
 
     def __hash__(self) -> int:
-        return hash((type(self), self._address))
+        return hash((type(self), *sorted(vars(self).items())))
 
     def _action_raw(self, signature: str, values: list) -> FuseAction:
         selector = function_signature_to_4byte_selector(signature)

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/multicall.py

@@ -43,7 +43,7 @@ class Multicall3(ContractWrapper):
 
     def __init__(
         self,
-        ctx: Web3Context,
+        ctx: Web3Context | None,
         address: ChecksumAddress = MULTICALL3_ADDRESS,
         batch_size: int = DEFAULT_BATCH_SIZE,
     ):
@@ -66,20 +66,22 @@ class Multicall3(ContractWrapper):
 
     def aggregate(self, calls: Sequence[Call[T]]) -> list[T]:
         """Execute all `calls`; raise as `Call.call()` would on any failure."""
+        ctx = self._require_ctx()
         raw = self._fetch(calls)
         if raw is None:
-            return [call.call(self._ctx) for call in calls]
+            return [call.call(ctx) for call in calls]
         return [
-            call.decode(data) if ok and data else call.call(self._ctx)
+            call.decode(data) if ok and data else call.call(ctx)
             for call, (ok, data) in zip(calls, raw, strict=True)
         ]
 
     def try_aggregate(self, calls: Sequence[Call[T]]) -> list[T | None]:
         """Execute all `calls`; ``None`` for each that reverts, returns no data
         or returns data its `Call` cannot decode."""
+        ctx = self._require_ctx()
         raw = self._fetch(calls)
         if raw is None:
-            return [_try_call(call, self._ctx) for call in calls]
+            return [_try_call(call, ctx) for call in calls]
         return [
             _try_decode(call, ok, data)
             for call, (ok, data) in zip(calls, raw, strict=True)

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/oracle.py

@@ -78,7 +78,7 @@ class PriceOracleMiddleware(ContractWrapper):
             Web3.keccak(text="AssetPriceSourceUpdated(address,address)")
         ).to_0x_hex()
         return list(
-            self._ctx.get_logs(
+            self._require_ctx().get_logs(
                 contract_address=self._address, topics=[event_signature_hash]
             )
         )
@@ -91,7 +91,7 @@ class LegacyPriceOracleMiddleware(PriceOracleMiddleware):
 
     def __init__(
         self,
-        ctx: Web3Context,
+        ctx: Web3Context | None,
         address: ChecksumAddress,
         base_currency_decimals: Decimals,
     ):

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/plasma_vault.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable, Sequence
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import Any, Self, TypeVar
+from typing import Any, TypeVar
 
 from eth_abi import decode, encode
 from eth_typing import ChecksumAddress
@@ -148,17 +148,13 @@ class PlasmaVault(ContractWrapper):
     service, multisig), grab the bytes directly: `vault.add_fuses(...).calldata`.
     """
 
-    def __init__(self, ctx: Web3Context, address: PlasmaVaultAddress):
+    def __init__(self, ctx: Web3Context | None, address: PlasmaVaultAddress):
         super().__init__(ctx, address)
 
     @property
     def address(self) -> PlasmaVaultAddress:
         return PlasmaVaultAddress(self._address)
 
-    @classmethod
-    def encoder(cls, address: PlasmaVaultAddress | None = None) -> Self:  # type: ignore[override]
-        return super().encoder(address)
-
     def execute(self, actions: list[FuseAction]) -> Call[None]:
         data = FuseAction.encode_execute_payload(actions, "execute((address,bytes)[])")
         return Call(to=self._address, data=data, ctx=self._ctx)
@@ -573,7 +569,7 @@ class PlasmaVault(ContractWrapper):
         ]
 
     def _address_at(self, slot: int) -> ChecksumAddress:
-        return _address_in_word(self._ctx.get_storage_at(self._address, slot))
+        return _address_in_word(self._require_ctx().get_storage_at(self._address, slot))
 
     def _is_own_withdraw_manager(self, candidate: ChecksumAddress) -> bool:
         call = Call(
@@ -650,7 +646,7 @@ class PlasmaVault(ContractWrapper):
             Web3.keccak(text="WithdrawManagerChanged(address)")
         ).to_0x_hex()
         return list(
-            self._ctx.get_logs(
+            self._require_ctx().get_logs(
                 contract_address=self._address, topics=[event_signature_hash]
             )
         )
@@ -658,7 +654,7 @@ class PlasmaVault(ContractWrapper):
     def _get_balance_fuse_events(self) -> list[LogReceipt]:
         """BalanceFuseAdded and BalanceFuseRemoved logs, from one eth_getLogs."""
         return list(
-            self._ctx.get_logs(
+            self._require_ctx().get_logs(
                 contract_address=self._address,
                 topics=[
                     [

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/core/withdraw_manager.py

@@ -120,7 +120,7 @@ class WithdrawManager(ContractWrapper):
 
         Replays `WithdrawRequestUpdated` from ``from_block``, or from the
         WithdrawManager's creation when None."""
-        current_timestamp = self._ctx.get_block()["timestamp"]
+        current_timestamp = self._require_ctx().get_block()["timestamp"]
         events = self._get_withdraw_request_updated_events(from_block=from_block)
 
         accounts: list[str] = []
@@ -137,7 +137,7 @@ class WithdrawManager(ContractWrapper):
 
         checksummed = [Web3.to_checksum_address(account) for account in accounts]
         calls = [self.request_info(account) for account in checksummed]
-        infos = Multicall3(self._ctx).try_aggregate(calls)
+        infos = Multicall3(self._require_ctx()).try_aggregate(calls)
         results: list[AccountRequest] = []
         for account, call, req in zip(checksummed, calls, infos, strict=True):
             if req is None:
@@ -164,7 +164,7 @@ class WithdrawManager(ContractWrapper):
         self,
         from_block: BlockNumber | None = None,
     ) -> PendingRequestsInfo:
-        current_timestamp = self._ctx.get_block()["timestamp"]
+        current_timestamp = self._require_ctx().get_block()["timestamp"]
         requests = self.get_pending_requests(from_block=from_block)
         total = sum(r.shares for r in requests)
         return PendingRequestsInfo(
@@ -180,7 +180,7 @@ class WithdrawManager(ContractWrapper):
             Web3.keccak(text="WithdrawRequestUpdated(address,uint256,uint32)")
         ).to_0x_hex()
         return list(
-            self._ctx.get_logs(
+            self._require_ctx().get_logs(
                 contract_address=self._address,
                 topics=[event_signature_hash],
                 from_block=from_block,

ipor_fusion-4.0.0.dev88/src/ipor_fusion/fuses/base.py

@@ -0,0 +1,17 @@
+"""Public path of the fuse encoder base, defined in `ipor_fusion.core.fuse`."""
+
+from ipor_fusion.core.address import (
+    _validate_not_zero_address as _validate_not_zero_address,
+)
+from ipor_fusion.core.fuse import Fuse as Fuse
+from ipor_fusion.core.fuse import StakeFuse as StakeFuse
+from ipor_fusion.core.fuse import (
+    _encode_address_substrate as _encode_address_substrate,
+)
+from ipor_fusion.core.fuse import (
+    _encode_uint248_substrate as _encode_uint248_substrate,
+)
+from ipor_fusion.core.fuse import _substrate_address_bytes as _substrate_address_bytes
+from ipor_fusion.core.fuse import _validate_selector as _validate_selector
+from ipor_fusion.core.fuse_action import FuseAction as FuseAction
+from ipor_fusion.types import ZERO_ADDRESS as ZERO_ADDRESS

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/fuses/crosschain/base.py

@@ -31,13 +31,10 @@ from eth_typing import ChecksumAddress
 from eth_utils import keccak
 from web3 import Web3
 
+from ipor_fusion.core.address import _validate_not_zero_address
+from ipor_fusion.core.fuse import Fuse, _substrate_address_bytes
+from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.crosschain.messages import Command
-from ipor_fusion.fuses.base import (
-    Fuse,
-    FuseAction,
-    _substrate_address_bytes,
-    _validate_not_zero_address,
-)
 from ipor_fusion.types import Amount, ChainId, MarketId
 
 _NO_CHAIN = ChainId(0)

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/fuses/crosschain/ccip.py

@@ -22,15 +22,16 @@ from enum import IntEnum
 
 from eth_typing import ChecksumAddress
 
+from ipor_fusion.core.fuse import Fuse
+from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.crosschain.ccip.contracts import CcipRouteConfig
 from ipor_fusion.crosschain.messages import COMMAND_TUPLE_TYPE, EMPTY_COMMAND, Command
-from ipor_fusion.fuses.base import ZERO_ADDRESS, Fuse, FuseAction
 from ipor_fusion.fuses.crosschain.base import (
     CrosschainCommandFuse,
     CrosschainSupplyFuse,
     SendParams,
 )
-from ipor_fusion.types import Amount, ChainId
+from ipor_fusion.types import ZERO_ADDRESS, Amount, ChainId
 
 
 @dataclass(frozen=True, slots=True)

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/fuses/crosschain/stargate.py

@@ -20,6 +20,8 @@ from enum import IntEnum
 
 from eth_typing import ChecksumAddress
 
+from ipor_fusion.core.fuse import Fuse
+from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.crosschain.messages import (
     COMMAND_TUPLE_TYPE,
     EMPTY_COMMAND,
@@ -27,7 +29,6 @@ from ipor_fusion.crosschain.messages import (
     Command,
 )
 from ipor_fusion.crosschain.stargate.layerzero import OptionsBuilder
-from ipor_fusion.fuses.base import Fuse, FuseAction
 from ipor_fusion.fuses.crosschain.base import (
     CrosschainCommandFuse,
     CrosschainSupplyFuse,

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev88}/src/ipor_fusion/fuses/universal.py

@@ -64,16 +64,6 @@ class UniversalTokenSwapperFuse(Fuse):
         super().__init__(address)
         self._abi = abi
 
-    def __eq__(self, other: object) -> bool:
-        return (
-            isinstance(other, UniversalTokenSwapperFuse)
-            and super().__eq__(other)
-            and self._abi is other._abi
-        )
-
-    def __hash__(self) -> int:
-        return hash((type(self), self._address, self._abi))
-
     def swap(
         self,
         *,