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

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

@@ -29,15 +29,22 @@ widths or address spelling.
 | `RoleId` | a `Roles` member (accepted as is), or `RoleId(n)`; `Roles.resolve(name)` returns one |
 | `Decimals`, `Period`, `Amount`, ... | `Decimals(8)`, `Period(0)`, `Amount(n)` (unchanged) |
 | `ChecksumAddress` | `Web3.to_checksum_address(value)` |
-| `HexAddress` | any `ChecksumAddress`, or `parse_hex_address(value)` (20 bytes or hex in any spelling → lowercase `0x` form) |
+| `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 |
-| `TxHash` | `parse_tx_hash(value)` (32 bytes or hex in any spelling) |
+| `TxHash` | `parse_tx_hash(value)` (32 bytes or `0x`/`0X`-prefixed hex in any case) |
 | `PlasmaVaultAddress`, `FuseAddress`, `AccessManagerAddress` | from the SDK (`PlasmaVault.address`, `get_fuses()`, `get_access_manager_address()`, `FusionInstance`, discovery), or `parse_plasma_vault_address` / `parse_fuse_address` / `parse_access_manager_address(value)` for a raw address; they label the role and check nothing on chain |
 | crosschain ids | `CommandId(b)`, `MessageId(b)`, `AssetId(b)`, `OperationId(b)`, `TransferId(b)`, `ReturnRequestId(b)`, `PositionSetHash(b)` (bytes32); `ProposalId(n)`, `DeploymentRequestId(n)`, `StargateAssetId(n)` (int) |
 | HyperCore ids | `HyperCoreTokenIndex(n)` (or `USDC_TOKEN_INDEX`), `HyperCoreAsset(n)` (or `hip3_action_asset(dex, index)`), `HyperCoreOrderId(n)`, `HyperCoreClientOrderId(n)`, `MarginTableId(n)`, `HyperCoreActionId(n)`, `PayloadHash(b)` |
 | external state | `ProposalHash(b)` |
 | `BlockIdentifier` | a block number, `"latest"` / `"pending"` / ..., or a block hash |
 
+The address and hash parsers (`parse_hex_address`, `parse_tx_hash`,
+`parse_plasma_vault_address`, `parse_fuse_address`, `parse_access_manager_address`)
+validate strictly: a string needs exactly one `0x`/`0X` prefix and the exact number of
+hex digits, with no surrounding whitespace; anything else raises `ValueError`. Strip
+user input yourself before parsing it. `parse_morpho_market_id` still accepts hex
+without `0x`.
+
 `MessageId` covers both a CCIP `messageId` and a LayerZero `guid`. `AssetId` is the
 crosschain executor's `bytes32` asset id; a Stargate pool's `uint16` asset id is
 `StargateAssetId`. `DeploymentRequestId` is a factory's `uint256` dispatcher request;
@@ -49,8 +56,9 @@ a `bytes32` return (recall) request is `ReturnRequestId`.
 `build_vault_info_json`, `ensure_supported_chain` and `fetch_vault_lending_health`
 take `ChainId`. The vault is a `PlasmaVaultAddress` (see *Address roles*) in
 `validate_vault` and `fetch_deployment_info`; `build_vault_info_json(ctx, plasma_vault,
-data, chain_id, chain_label)` takes no address and labels the document with
-`plasma_vault.address`. `fetch_unpriceable_priced_tokens` takes the oracle and
+data, *, chain_id, chain_label)` takes no address, takes the chain by keyword, and
+labels the document with `plasma_vault.address` (a test that mocks `PlasmaVault`
+sets `.address`). `fetch_unpriceable_priced_tokens` takes the oracle and
 underlying as `ChecksumAddress`. `resolve_token_symbol`, `resolve_token_decimals`,
 `get_contract_name` and `get_deployment_tx` take `HexAddress` (a checksum address
 fits), and the `resolve_name` / `resolve_symbol` callbacks receive one (a callback
@@ -102,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.dev63 → ipor_fusion-4.0.0.dev68}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev63"
+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.dev63 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/cli/vault_info_view.py

@@ -98,8 +98,8 @@ def _print_vault_info(
             ctx,
             plasma_vault,
             data,
-            chain_id,
-            chain_label,
+            chain_id=chain_id,
+            chain_label=chain_label,
             resolve_name=partial(get_contract_name, chain_id, api_key=api_key),
         )
         click.echo(json.dumps(result, indent=2))

{ipor_fusion-4.0.0.dev63 → 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.dev63 → 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.dev63 → 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.dev63 → 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.dev63 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/fuses/external_state_events.py

@@ -196,7 +196,12 @@ def external_state_event_name(topic: bytes | str) -> str | None:
 def _hex(value: Any) -> TxHash | None:
     if value is None:
         return None
-    return parse_tx_hash(_as_bytes(value, "transactionHash"))
+    raw = _as_bytes(value, "transactionHash")
+    if len(raw) != 32:
+        raise ExternalStateEventDecodeError(
+            f"transactionHash: {len(raw)} bytes, expected 32"
+        )
+    return parse_tx_hash(raw)
 
 
 def decode_external_state_event(log: Mapping[str, Any]) -> ExternalStateEvent | None:

{ipor_fusion-4.0.0.dev63 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/mcp/server.py

@@ -216,8 +216,8 @@ def vault_info(
         ctx,
         plasma_vault,
         data,
-        chain_id,
-        chain_label,
+        chain_id=chain_id,
+        chain_label=chain_label,
         resolve_name=partial(get_contract_name, chain_id, api_key=api_key),
     )
     return VaultInfoResponse.model_validate(result)

{ipor_fusion-4.0.0.dev63 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/substrates.py

@@ -47,10 +47,15 @@ class SubstrateInfo:
 #   Slippage variant: [2 type chars][62 value chars]
 
 
+def _address(hex_digits: str) -> HexAddress:
+    """The address in 40 hex digits sliced out of a substrate word."""
+    return parse_hex_address("0x" + hex_digits)
+
+
 def _decode_type_lshift160(hex_str: str, types: dict[int, str]) -> SubstrateInfo:
     """Decode type<<160 | address (Ebisu, Midas, Balancer, Velodrome)."""
     type_byte = int(hex_str[22:24], 16)
-    addr = parse_hex_address(hex_str[24:])
+    addr = _address(hex_str[24:])
     label = types.get(type_byte, f"type={type_byte}")
     return SubstrateInfo(address=addr, type_label=label)
 
@@ -63,13 +68,13 @@ def _decode_type_lshift248(hex_str: str, types: dict[int, str]) -> SubstrateInfo
         return SubstrateInfo(
             raw_hex=f"0x{hex_str}", type_label=label, extra={"slippage": str(value)}
         )
-    addr = parse_hex_address(hex_str[24:])
+    addr = _address(hex_str[24:])
     return SubstrateInfo(address=addr, type_label=label)
 
 
 def _decode_plain_address(hex_str: str) -> SubstrateInfo:
     """Decode zero-padded address: 12 zero bytes + 20 address bytes."""
-    return SubstrateInfo(address=parse_hex_address(hex_str[24:]))
+    return SubstrateInfo(address=_address(hex_str[24:]))
 
 
 def _decode_morpho(hex_str: str) -> SubstrateInfo:
@@ -84,14 +89,14 @@ def _decode_uniswap_v4(hex_str: str) -> SubstrateInfo:
     substrate-as-asset (12 zero bytes + address)."""
     if hex_str[:24] == "0" * 24:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[24:]), type_label="uniswap_v4_token"
+            address=_address(hex_str[24:]), type_label="uniswap_v4_token"
         )
     return SubstrateInfo(raw_hex=f"0x{hex_str}", type_label="uniswap_v4_pool_id")
 
 
 def _decode_enso(hex_str: str) -> SubstrateInfo:
     """Decode address<<96 | selector<<64 (Enso)."""
-    addr = parse_hex_address(hex_str[0:40])
+    addr = _address(hex_str[0:40])
     selector = f"0x{hex_str[40:48]}"
     return SubstrateInfo(
         address=addr, type_label="ENSO_TARGET", extra={"selector": selector}
@@ -100,7 +105,7 @@ def _decode_enso(hex_str: str) -> SubstrateInfo:
 
 def _decode_dolomite(hex_str: str) -> SubstrateInfo:
     """Decode asset<<96 | subAccountId<<88 | canBorrow<<80 (Dolomite)."""
-    addr = parse_hex_address(hex_str[0:40])
+    addr = _address(hex_str[0:40])
     sub_account_id = int(hex_str[40:42], 16)
     can_borrow = (int(hex_str[42:44], 16) & 0x01) == 1
     return SubstrateInfo(
@@ -127,7 +132,7 @@ def _decode_aave_v4(hex_str: str) -> SubstrateInfo:
         return SubstrateInfo(raw_hex=f"0x{hex_str}", type_label=label)
     flags = int(hex_str[50:52], 16)
     return SubstrateInfo(
-        address=parse_hex_address(hex_str[2:42]),
+        address=_address(hex_str[2:42]),
         type_label="AAVE_V4_RESERVE",
         extra={
             "reserve_id": str(int(hex_str[42:50], 16)),
@@ -145,7 +150,7 @@ def _decode_euler_v2(hex_str: str) -> SubstrateInfo:
     plain-address path silently produces a malformed address (last 20 bytes are
     flag bytes + zero padding).
     """
-    addr = parse_hex_address(hex_str[0:40])
+    addr = _address(hex_str[0:40])
     is_collateral = (int(hex_str[40:42], 16) & 0x01) == 1
     can_borrow = (int(hex_str[42:44], 16) & 0x01) == 1
     sub_account = f"0x{hex_str[44:46]}"
@@ -174,13 +179,13 @@ def _decode_async_action(hex_str: str) -> SubstrateInfo:
     type_byte = int(hex_str[0:2], 16)
     if type_byte == 0:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[2:42]),
+            address=_address(hex_str[2:42]),
             type_label="ALLOWED_AMOUNT_TO_OUTSIDE",
             extra={"amount": str(int(hex_str[42:64], 16))},
         )
     if type_byte == 1:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[16:56]),
+            address=_address(hex_str[16:56]),
             type_label="ALLOWED_TARGETS",
             extra={"selector": f"0x{hex_str[56:64]}"},
         )
@@ -225,10 +230,10 @@ def _decode_external_state(hex_str: str) -> SubstrateInfo:
     if type_byte == 0:
         return SubstrateInfo(raw_hex=f"0x{hex_str}", type_label="UNDEFINED")
     if label := _EXTERNAL_STATE_ADDRESS_TYPES.get(type_byte):
-        return SubstrateInfo(address=parse_hex_address(hex_str[24:]), type_label=label)
+        return SubstrateInfo(address=_address(hex_str[24:]), type_label=label)
     if type_byte == 2:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[24:]),
+            address=_address(hex_str[24:]),
             type_label="TARGET",
             extra={"selector": f"0x{hex_str[16:24]}"},
         )
@@ -266,7 +271,7 @@ def _decode_crosschain(hex_str: str) -> SubstrateInfo:
             is_error=True,
             extra={"chain_id": str(chain_id)},
         )
-    info = SubstrateInfo(address=parse_hex_address(hex_str[24:]), type_label=label)
+    info = SubstrateInfo(address=_address(hex_str[24:]), type_label=label)
     if type_byte == 2:
         info.extra = {"chain_id": str(chain_id)}
     return info
@@ -326,7 +331,7 @@ def _decode_hypercore(hex_str: str) -> SubstrateInfo:
         return _hypercore_invalid(hex_str, label)
     if type_byte == 1:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[24:]),
+            address=_address(hex_str[24:]),
             type_label=label,
             extra={"token_index": str(int(hex_str[8:24], 16))},
         )
@@ -347,10 +352,10 @@ def _decode_hypercore(hex_str: str) -> SubstrateInfo:
             extra["read_index"] = str(read_index_of(asset))
         return SubstrateInfo(raw_hex=f"0x{hex_str}", type_label=label, extra=extra)
     if type_byte == 3:
-        return SubstrateInfo(address=parse_hex_address(hex_str[24:]), type_label=label)
+        return SubstrateInfo(address=_address(hex_str[24:]), type_label=label)
     if type_byte == 4:
         return SubstrateInfo(
-            address=parse_hex_address(hex_str[24:]),
+            address=_address(hex_str[24:]),
             type_label=label,
             extra={"max_fee_rate_decibps": str(int(hex_str[8:24], 16))},
         )

{ipor_fusion-4.0.0.dev63 → ipor_fusion-4.0.0.dev68}/src/ipor_fusion/types.py

@@ -145,22 +145,28 @@ def _hex_digits(value: str | bytes, size: int, what: str) -> str:
         if len(value) != size:
             raise ValueError(f"invalid {what} (expected {size} bytes): {value!r}")
         return value.hex()
-    digits = value.strip().removeprefix("0x").removeprefix("0X").lower()
-    if len(digits) != 2 * size or any(c not in "0123456789abcdef" for c in digits):
-        raise ValueError(f"invalid {what} (expected {size}-byte hex): {value}")
+    digits = value[2:].lower()
+    if (
+        value[:2] not in ("0x", "0X")
+        or len(digits) != 2 * size
+        or any(c not in "0123456789abcdef" for c in digits)
+    ):
+        raise ValueError(f"invalid {what} (expected 0x and {size}-byte hex): {value!r}")
     return digits
 
 
 def parse_hex_address(value: str | bytes) -> HexAddress:
-    """An address as ``0x`` and 40 lowercase hex digits, from 20 raw bytes or hex
-    in any spelling; raises ``ValueError`` on anything else. For a checksummed
+    """An address as ``0x`` and 40 lowercase hex digits, from 20 raw bytes or
+    ``0x``-prefixed hex in any case; raises ``ValueError`` on anything else,
+    surrounding whitespace included. For a checksummed
     address use ``Web3.to_checksum_address``."""
     return HexAddress(HexStr("0x" + _hex_digits(value, 20, "address")))
 
 
 def parse_tx_hash(value: str | bytes) -> TxHash:
     """A transaction hash as ``0x`` and 64 lowercase hex digits, from 32 raw bytes
-    or hex in any spelling; raises ``ValueError`` on anything else."""
+    or ``0x``-prefixed hex in any case; raises ``ValueError`` on anything else,
+    surrounding whitespace included."""
     return TxHash(HexStr("0x" + _hex_digits(value, 32, "transaction hash")))
 
 
@@ -169,9 +175,10 @@ def _checksum(value: str | bytes) -> ChecksumAddress:
 
 
 def parse_plasma_vault_address(value: str | bytes) -> PlasmaVaultAddress:
-    """A Plasma Vault's address, checksummed from 20 raw bytes or hex in any
-    spelling; raises ``ValueError`` on anything else. It labels the role and
-    checks nothing on chain."""
+    """A Plasma Vault's address, checksummed from 20 raw bytes or ``0x``/``0X``
+    and 40 hex digits in any case; raises ``ValueError`` on anything else,
+    surrounding whitespace included. It labels the role and checks nothing on
+    chain."""
     return PlasmaVaultAddress(_checksum(value))
 
 

{ipor_fusion-4.0.0.dev63 → ipor_fusion-4.0.0.dev68}/tests/test_cli_vault_info_golden.py

@@ -378,8 +378,8 @@ def test_public_builder_renders_the_cli_json(scenario: str) -> None:
         ctx,
         PlasmaVault(ctx, VAULT),  # type: ignore[arg-type]
         data,
-        1,
-        "ethereum",
+        chain_id=1,
+        chain_label="ethereum",
         resolve_name=lambda address: _NAMES_BY_ADDRESS.get(address.lower(), ""),
     )
     expected = (FIXTURES / f"{scenario}.json").read_text(encoding="utf-8")

{ipor_fusion-4.0.0.dev63 → ipor_fusion-4.0.0.dev68}/tests/test_external_state_events.py

@@ -96,6 +96,13 @@ def test_hex_text_data_and_topics_from_an_indexer_decode_too():
     assert event.transaction_hash == "0x" + "fb" * 32
 
 
+def test_a_short_transaction_hash_is_a_decode_error():
+    log = _log("ExternalStateAssetRescued", (SIGNER,))
+    log["transactionHash"] = bytes(31)
+    with pytest.raises(ExternalStateEventDecodeError, match="transactionHash"):
+        decode_external_state_event(log)
+
+
 def test_an_unknown_topic_is_none_and_a_malformed_listed_one_raises():
     assert (
         decode_external_state_event(

{ipor_fusion-4.0.0.dev63 → 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.dev63 → 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)