ipor-fusion 4.0.0.dev66__tar.gz → 4.0.0.dev68__tar.gz

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/MIGRATION_4.md

@@ -110,6 +110,15 @@ Every fuse constructor, `FuseAction.fuse`, `BalanceFuse.fuse`,
 `FusionInstance.access_manager` return one. `resolve_access_manager` still takes any
 `ChecksumAddress`: it is what checks that the address is a vault.
 
+**Simulation and factory records.** `VaultSimulator(web3, *, vault=None, alpha=None,
+block=...)` takes every argument after `web3` by keyword, and `vault` and `alpha` are
+optional: a simulator that only observes, deploys or sends `execute_call(call,
+from_=...)` needs neither, so drop a zero-address placeholder. `execute()` without
+`vault` and `alpha` raises `ValueError`, as does `execute_call` without `from_` or
+`alpha`. `FusionInstance.from_dict(data)` rebuilds a stored instance (the
+`dataclasses.asdict` form) with every field parsed; use it instead of
+`FusionInstance(**data)`, which passes raw strings into the role-typed fields.
+
 **Markets and substrates.** Every `IporFusionMarkets` member is a `MarketId`.
 `decode_substrate`, `market_name`, `format_market_label` take `MarketId`.
 

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/core/fusion_factory.py

@@ -22,7 +22,9 @@ For external-signer flows, grab the bytes directly:
 
 from __future__ import annotations
 
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
+from typing import Any
 
 from eth_abi import decode as abi_decode
 from eth_typing import ChecksumAddress
@@ -31,7 +33,13 @@ from web3 import Web3
 from web3.types import TxReceipt
 
 from ipor_fusion.core.contract import Call, ContractWrapper
-from ipor_fusion.types import AccessManagerAddress, Period, PlasmaVaultAddress
+from ipor_fusion.types import (
+    AccessManagerAddress,
+    Period,
+    PlasmaVaultAddress,
+    parse_access_manager_address,
+    parse_plasma_vault_address,
+)
 
 
 @dataclass(slots=True, frozen=True)
@@ -70,6 +78,61 @@ class FusionInstance:
     context_manager: ChecksumAddress
     price_manager: ChecksumAddress
 
+    @classmethod
+    def from_dict(
+        cls, data: Mapping[str, Any]
+    ) -> FusionInstance:  # proctor: ignore[primitives-untyped-dict]
+        """Rebuild an instance from its JSON form (``dataclasses.asdict``),
+        parsing every field: role addresses through their parsers, the rest
+        checksummed, integers and strings type-checked. Raises ``ValueError``
+        on a missing, extra or malformed field."""
+        missing = _INSTANCE_FIELDS.keys() - data.keys()
+        extra = data.keys() - _INSTANCE_FIELDS.keys()
+        if missing or extra:
+            raise ValueError(
+                f"FusionInstance fields: missing {sorted(missing)}, extra {sorted(extra)}"
+            )
+        return cls(
+            **{name: parse(data[name]) for name, parse in _INSTANCE_FIELDS.items()}
+        )
+
+
+def _integer(value: Any) -> int:
+    if type(value) is not int:
+        raise ValueError(f"expected an integer: {value!r}")
+    return value
+
+
+def _text(value: Any) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"expected a string: {value!r}")
+    return value
+
+
+def _address(value: Any) -> ChecksumAddress:
+    return Web3.to_checksum_address(_text(value))
+
+
+_INSTANCE_FIELDS: dict[str, Callable[[Any], Any]] = {
+    "index": _integer,
+    "version": _integer,
+    "asset_name": _text,
+    "asset_symbol": _text,
+    "asset_decimals": _integer,
+    "underlying_token": _address,
+    "underlying_token_symbol": _text,
+    "underlying_token_decimals": _integer,
+    "initial_owner": _address,
+    "plasma_vault": lambda value: parse_plasma_vault_address(_text(value)),
+    "plasma_vault_base": _address,
+    "access_manager": lambda value: parse_access_manager_address(_text(value)),
+    "fee_manager": _address,
+    "rewards_manager": _address,
+    "withdraw_manager": _address,
+    "context_manager": _address,
+    "price_manager": _address,
+}
+
 
 _FUSION_INSTANCE_OUTPUT_TYPES: list[str] = [
     "uint256",  # index

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/core/simulation.py

@@ -16,7 +16,7 @@ from web3.utils.address import get_create_address
 from ipor_fusion.core.contract import Call, _encode_calldata
 from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.errors import SimulationError, decode_custom_error
-from ipor_fusion.types import ZERO_ADDRESS, PlasmaVaultAddress
+from ipor_fusion.types import PlasmaVaultAddress
 
 #: ``n`` (the sent block's index in the run) -> account overrides for it.
 StateOverrideProvider = Callable[[int], Mapping[str, Mapping[str, Any]]]
@@ -190,15 +190,16 @@ class VaultSimulator:
     def __init__(
         self,
         web3: Web3,
-        vault: PlasmaVaultAddress,
-        alpha: ChecksumAddress,
+        *,
+        vault: PlasmaVaultAddress | None = None,
+        alpha: ChecksumAddress | None = None,
         block: BlockIdentifier = "latest",
         validation: bool = False,
         trace_transfers: bool = False,
     ):
         self._web3 = web3
-        self._vault = Web3.to_checksum_address(vault)
-        self._alpha = Web3.to_checksum_address(alpha)
+        self._vault = vault
+        self._alpha = alpha
         self._block: BlockIdentifier = block
         self._validation = validation
         self._trace_transfers = trace_transfers
@@ -341,6 +342,8 @@ class VaultSimulator:
 
     def execute(self, actions: list[FuseAction]) -> VaultSimulator:
         """Queue a default `execute((address,bytes)[])` batch on the vault, from alpha."""
+        if self._vault is None or self._alpha is None:
+            raise ValueError("execute needs a simulator built with vault= and alpha=")
         data = FuseAction.encode_execute_payload(actions, "execute((address,bytes)[])")
         return self._queue_execute(self._vault, data, self._alpha)
 
@@ -351,11 +354,12 @@ class VaultSimulator:
         e.g. `RewardsManager.claim_rewards(...)` where the wrapper differs from
         `PlasmaVault.execute`. `from_` defaults to alpha.
         """
-        return self._queue_execute(
-            call.to,
-            call.data,
-            Web3.to_checksum_address(from_) if from_ else self._alpha,
-        )
+        sender = from_ or self._alpha
+        if sender is None:
+            raise ValueError(
+                "execute_call needs from_ or a simulator built with alpha="
+            )
+        return self._queue_execute(call.to, call.data, sender)
 
     def _queue_execute(
         self, to: ChecksumAddress, data: bytes, from_: ChecksumAddress
@@ -751,8 +755,7 @@ def erc20_balance_slot(
     if max_slot < 0:
         raise ValueError(no_slot)
 
-    zero: Any = ZERO_ADDRESS
-    sim = VaultSimulator(web3, vault=zero, alpha=zero, block=block)
+    sim = VaultSimulator(web3, block=block)
     for slot in range(max_slot + 1):
         holder = Web3.to_checksum_address(
             "0x" + keccak(encode(["uint256"], [slot]))[-20:].hex()

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/crosschain/ccip/quote.py

@@ -18,13 +18,11 @@ from web3.types import BlockIdentifier
 
 from ipor_fusion.core.contract import Call
 from ipor_fusion.core.simulation import VaultSimulator
-from ipor_fusion.types import parse_plasma_vault_address
 
 #: Selector of ``CcipInsufficientNativeFeeBalance(uint256 balance, uint256 required)``.
 INSUFFICIENT_NATIVE_FEE_SELECTOR: bytes = keccak(
     text="CcipInsufficientNativeFeeBalance(uint256,uint256)"
 )[:4]
-_NO_VAULT = parse_plasma_vault_address(bytes(20))
 
 
 def quote_ccip_native_fee(
@@ -45,7 +43,7 @@ def quote_ccip_native_fee(
     valid at ``block`` up to the fee check; a revert before it, or a call that
     sends no message, raises ``ValueError``.
     """
-    simulator = VaultSimulator(web3, vault=_NO_VAULT, alpha=from_, block=block)
+    simulator = VaultSimulator(web3, alpha=from_, block=block)
     simulator.with_state_override(payer, balance=hex(0))
     simulator.add_call(call, from_=from_, label="quote", gas=gas)
     (result,) = simulator.run().calls

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/crosschain/simulation.py

@@ -25,7 +25,6 @@ Example -- bridge from a source vault and let the dispatcher settle::
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Any
 
 from eth_typing import ChecksumAddress
 from web3 import Web3
@@ -41,7 +40,7 @@ from ipor_fusion.crosschain.transport import (
     CrosschainTransport,
     OutboundMessage,
 )
-from ipor_fusion.types import ZERO_ADDRESS, ChainId, PlasmaVaultAddress
+from ipor_fusion.types import ChainId, PlasmaVaultAddress
 
 #: What the synthetic token source holds: enough for any test amount.
 SYNTHETIC_BALANCE = 2**96
@@ -89,10 +88,7 @@ class CrosschainSimulator:
             raise ValueError(f"chain {chain_id} is not configured on the transport")
         if chain_id in self._chains:
             raise ValueError(f"chain {chain_id} already added")
-        zero: Any = ZERO_ADDRESS
-        sim = VaultSimulator(
-            web3, vault=vault or zero, alpha=alpha or zero, block=block
-        )
+        sim = VaultSimulator(web3, vault=vault, alpha=alpha, block=block)
         # A chain without a real token holder to impersonate gets a synthetic
         # one, funded once by a storage override; deliveries transfer from it.
         for token in self._transport.synthetic_credit_tokens(chain_id):

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/tests/test_external_state_executor.py

@@ -64,7 +64,7 @@ def _observed(call, return_data: bytes):
     Feeds a synthetic `eth_simulateV1` response to `_parse_response`, so the
     result is whatever `observe` would actually report -- including its handling
     of a decoder that raises."""
-    sim = VaultSimulator(MagicMock(), EXECUTOR_ADDR, EXECUTOR_ADDR)
+    sim = VaultSimulator(MagicMock())
     sim.observe("slot", call)
     result = sim._parse_response(
         simulate_response(

ipor_fusion-4.0.0.dev68/tests/test_fusion_instance.py

@@ -0,0 +1,70 @@
+"""`FusionInstance.from_dict` parses a stored instance back into its typed
+fields instead of passing raw JSON strings into role-typed addresses."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+
+import pytest
+from web3 import Web3
+
+from ipor_fusion.core.fusion_factory import FusionInstance
+
+
+def _stored() -> dict:
+    address = {
+        name: "0x" + f"{i:02x}" * 20
+        for i, name in enumerate(
+            [
+                "underlying_token",
+                "initial_owner",
+                "plasma_vault",
+                "plasma_vault_base",
+                "access_manager",
+                "fee_manager",
+                "rewards_manager",
+                "withdraw_manager",
+                "context_manager",
+                "price_manager",
+            ],
+            start=0xA1,
+        )
+    }
+    return {
+        "index": 3,
+        "version": 2,
+        "asset_name": "IPOR USDC",
+        "asset_symbol": "ipUSDC",
+        "asset_decimals": 8,
+        "underlying_token_symbol": "USDC",
+        "underlying_token_decimals": 6,
+        **address,
+    }
+
+
+def test_from_dict_checksums_every_address_and_round_trips():
+    stored = _stored()
+    instance = FusionInstance.from_dict(stored)
+    assert instance.plasma_vault == Web3.to_checksum_address(stored["plasma_vault"])
+    assert instance.access_manager == Web3.to_checksum_address(stored["access_manager"])
+    assert instance.price_manager == Web3.to_checksum_address(stored["price_manager"])
+    assert FusionInstance.from_dict(asdict(instance)) == instance
+
+
+@pytest.mark.parametrize(
+    ("change", "match"),
+    [
+        (lambda d: d.pop("plasma_vault"), "missing"),
+        (lambda d: d.update(extra=1), "extra"),
+        (lambda d: d.update(plasma_vault="0x1234"), "address"),
+        (lambda d: d.update(plasma_vault=" " + d["plasma_vault"]), "address"),
+        (lambda d: d.update(asset_decimals="8"), "integer"),
+        (lambda d: d.update(index=True), "integer"),
+        (lambda d: d.update(asset_symbol=None), "string"),
+    ],
+)
+def test_from_dict_rejects_a_malformed_field(change, match):
+    stored = _stored()
+    change(stored)
+    with pytest.raises(ValueError, match=match):
+        FusionInstance.from_dict(stored)

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/tests/test_simulate_crosschain_hyperevm.py

@@ -343,7 +343,6 @@ def test_simulate_contract_creation(web3_arb):
     init_code = bytes.fromhex("600a600c600039600a6000f3") + runtime
     simulator = VaultSimulator(
         web3_arb,
-        vault=ZERO_ADDRESS,
         alpha=SIMULATED_DEPLOYER,
         block=ARBITRUM_BLOCK,
     )
@@ -374,7 +373,6 @@ def test_compile_and_deploy_crosschain_fuses(web3_arb):
     )
     simulator = VaultSimulator(
         web3_arb,
-        vault=ZERO_ADDRESS,
         alpha=SIMULATED_DEPLOYER,
         block=ARBITRUM_BLOCK,
     )
@@ -804,7 +802,7 @@ def test_simulate_clone_htest_vault(
         OWNER,
     )
     preview = clone.call()
-    simulator = VaultSimulator(web3, vault=ZERO_ADDRESS, alpha=OWNER, block=block)
+    simulator = VaultSimulator(web3, alpha=OWNER, block=block)
     simulator.with_block_override(gasLimit=30_000_000)
     simulator.add_call(clone, from_=OWNER, label="clone_vault")
     vault = PlasmaVault(ctx, preview.plasma_vault)

{ipor_fusion-4.0.0.dev66 → ipor_fusion-4.0.0.dev68}/tests/test_vault_simulator_blocks.py

@@ -573,3 +573,14 @@ def test_add_transaction_rejects_what_it_cannot_send_faithfully(transaction, mes
     sim, _ = _simulator()
     with pytest.raises(ValueError, match=message):
         sim.add_transaction(transaction)
+
+
+def test_a_simulator_without_vault_or_alpha_observes_but_cannot_execute():
+    sim = VaultSimulator(MagicMock(), block=100)
+    call = Call(to=PAYER, data=b"\x01", ctx=MagicMock())
+    with pytest.raises(ValueError, match="vault= and alpha="):
+        sim.execute([])
+    with pytest.raises(ValueError, match="from_ or"):
+        sim.execute_call(call)
+    sim.execute_call(call, from_=PAYER)
+    assert sim.has_calls