ipor-fusion 4.0.0.dev308__tar.gz → 4.0.0.dev315__tar.gz

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/AGENTS.md

@@ -3,9 +3,7 @@
 `ipor-fusion` is the Python SDK for IPOR Fusion Plasma Vaults: typed fuse
 encoders, on-chain readers, and a `fusion` CLI plus `fusion-mcp` MCP server
 built on the same SDK. Published to PyPI. It is a library and inspection
-tooling, not an automation service. `scripts/crosschain_readiness.py` is a
-read-only diagnostic run on demand, not a keeper or production monitor; any
-scheduled run of it belongs to the monitoring repository.
+tooling, not an automation service.
 
 Related repositories (siblings, referenced by name; clone paths vary):
 - [ipor-fusion](https://github.com/IPOR-Labs/ipor-fusion) — Solidity contracts, the source of truth for market ids, roles and substrates.
@@ -29,8 +27,6 @@ uv run ruff check ./                                          # lint: bandit S,
 uv run pyright                                                # types, basic mode, src + tests + examples + scripts
 uv run pytest                                                 # all tests + coverage gate (fail_under = 98, mcp/ included)
 uv run pytest -m "cli or mcp" --no-cov                        # CLI/MCP subset (the full suite is mostly offline too)
-uv run pytest --run-readiness -m readiness --no-cov -rA       # opt-in live Ethereum-hub POC checks
-uv run python scripts/crosschain_readiness.py --output /tmp/crosschain-readiness.json # live Arbitrum/HyperEVM report
 uv run pytest tests/test_fuse_encoding.py -k aave --no-cov    # single file / test
 UPDATE_GOLDEN=1 uv run pytest -k golden --no-cov              # rewrite pinned CLI/MCP output (tests/fixtures/*_golden/)
 uv lock --check                                               # uv.lock in sync with pyproject.toml
@@ -74,14 +70,13 @@ public Solidity sources from GitHub). Skip only for an unavailable source; an
 exception from the
 SDK is a test failure, never a skip. Never print `.env` or a provider URL: they
 embed API keys, so skip and fail messages carry the exception type only.
-`HYPEREVM_PROVIDER_URL` is used by the HyperEVM lifecycle/deployment tests and
-the readiness script; general PR CI does not supply it.
-`test_simulate_crosschain_hyperevm.py` rehearses Arbitrum → HyperEVM on pinned blocks,
-parametrized by `generation`: `v2` and `v3` run the live factory pairs (`FactoryPair`:
-address, pins, creation-code hashes, route and dispatcher deployment gas limits) with
-executors from the creation code they store; `source` builds a factory pair from
-`FUSE_SOURCE_REVISION` inside the simulation. All need `IPOR_FUSION_CONTRACTS_DIR` at
-that revision (the fuses are compiled from it); a checkout without `node_modules` also
+`HYPEREVM_PROVIDER_URL` is used by the Arbitrum → HyperEVM rehearsal and the
+HyperCore tests; general PR CI does not supply it.
+`test_simulate_crosschain_hyperevm.py` rehearses Arbitrum → HyperEVM on pinned blocks
+with a CCIP factory pair compiled from `FUSE_SOURCE_REVISION` (the contracts release
+the official deployment was built from) and built inside the simulation; the SDK
+supports only that release, so there is no live-pair generation. It needs
+`IPOR_FUSION_CONTRACTS_DIR` at that revision; a checkout without `node_modules` also
 needs `IPOR_FUSION_FOUNDRY_REMAPPINGS` for OpenZeppelin. `test_crosschain_ccip_events.py`
 mirrors the CCIP event registry from a checkout at its own `CONTRACTS_REVISION`.
 `test_solidity_compiler.py` unit-tests that compiler helper (`tests/_foundry.py`)
@@ -89,18 +84,6 @@ offline, with `forge` and `git` mocked. The checkout-based tests above skip when
 external prerequisites are unavailable. `test_hypercore_live.py`,
 `test_hypercore_deployment.py` and `test_hypercore_simulation.py` need
 `HYPEREVM_PROVIDER_URL` as well.
-`test_simulate_crosschain_lifecycle.py` drives the mainnet POC deployment from
-Ethereum to every spoke on every transport through `CrosschainLane` and
-`CrosschainSimulator`; the fixtures (`Chain`, `Deployment`, `Spoke`, pinned
-blocks) live in `tests/_crosschain.py`. A planned spoke (HyperEVM) is a
-`pending` chain there and an `xfail(strict=True)` param until it is wired.
-`test_simulate_crosschain_canary.py` runs the same lifecycle on `CANARY` and
-`CANARY_V3`, the live Arbitrum → HyperEVM USDC canaries on the pilot-v2 and v3 CCIP
-factory pairs, each pinned right after its last transaction, then checks the final gates and every delivery's receiver
-gas against its route limit; a `Chain.simulated_gas_limit` lifts HyperEVM's 3 M
-small-block pin to 30 M and `Deployment.ccip_debits_sent_amount` /
-`attestation_zero_dust_sd` carry the executor generation's accounting into `Run`.
-It needs `ARBITRUM_PROVIDER_URL` and `HYPEREVM_PROVIDER_URL`.
 HyperCore (market 55) cannot be simulated directly: the HyperEVM RPC ignores code
 overrides at the precompile addresses `0x800`–`0x813`, and the public Hyperliquid RPC
 has no `eth_simulateV1`. `tests/_hypercore_shadow.py` therefore compiles the HyperCore
@@ -110,33 +93,8 @@ CoreWriter constants redirected to ordinary addresses, proves the rest is identi
 the deployed runtimes, and `tests/_hypercore_model.py` answers those addresses through
 `VaultSimulator.with_state_override_provider`. Core never applies anything there: the
 tests prove EVM validation under supplied Core state. `test_hypercore_simulation.py`
-runs one vault cycle; `test_simulate_crosschain_hypercore.py` runs the composed flow
-(v3 canary hub → CCIP → the market-55 vault → a trade → recall → claim) and holds every
-CCIP delivery to its route gas limit. Both skip without the source directory;
-`test_hypercore_simulation.py` also needs `HYPEREVM_PROVIDER_URL`, the composed flow
-`ARBITRUM_PROVIDER_URL` as well.
-`test_crosschain_readiness.py` checks the Ethereum-hub POC's live bridge and IPOR
-preconditions. Its `readiness` marker requires `--run-readiness`: ordinary runs
-exclude it even with `-m sdk`. Known HyperEVM gaps are non-strict xfails restricted
-to assertion failures, so availability improving is an XPASS, not broken CI.
-Readiness RPC clients fail on missing/unreachable providers or wrong chain IDs;
-they pin a snapshot per chain and do not require `eth_simulateV1`.
-`scripts/crosschain_readiness.py` separately reports both Arbitrum/HyperEVM USDC
-directions and the v3 factory pair's configuration (creation codes, routes, the
-dispatcher deployment gas limit, the canary creator's allowance, balance and HyperEVM
-big-block flag) with snapshot block numbers/hashes/timestamps. `hyperevm_delivery`
-flags manual execution into HyperEVM per message kind: `manual_execution_required` for
-commands and recalls (the hub route's `messageGasLimit`) and `dispatcher_deployment_manual`
-for the one-time deployment ticket. A delivery above the 3 M small block is manual
-unless every Chainlink executor seen delivering on HyperEVM's CCIP 2.0 OffRamp over
-the last ~2 weeks (`chainlink_executors`: `ExecutionStateChanged` senders from every
-source, the canary EOA excluded, at least 20 executions) sends into big blocks; a
-ticket below a dispatcher creation's gas is manual regardless. The executor set is
-derived on every run; `eth_usingBigBlocks` is read at the latest block.
-Blocked availability is a successful observation, not acceptance; incomplete probes
-fail. There is no GitHub workflow for it in this repository: run it locally with
-the Arbitrum and HyperEVM provider URLs from `.env`. A `Spoke` declares which transports reach it;
-the lifecycle matrix follows that.
+runs one vault cycle; it skips without the source directory and needs
+`HYPEREVM_PROVIDER_URL`.
 
 ## Conventions
 
@@ -237,6 +195,11 @@ the lifecycle matrix follows that.
 
 - `chains.py` chain registry; `market_ids.py` `IporFusionMarkets`; `types.py`; `errors.py`
   defines every SDK exception class (`tests/test_error_hierarchy.py` pins it)
+- `fusion_errors.py` — `FUSION_ERROR_SIGNATURES`, every custom error of the
+  ipor-fusion contracts and their imports, registered by `errors.py` so reverts
+  decode by name; generated, never edited by hand: `uv run python
+  scripts/fusion_error_signatures.py ../ipor-fusion --source <commit>` (needs the
+  checkout's `npm ci`)
 - `about.py` — package version, repository URL, CHANGELOG parsing (`fusion changelog`,
   `server_info`); `field_docs.py` — `DOCS`, the JSON field descriptions shared by CLI
   output and MCP models

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/MIGRATION_4.md

@@ -503,6 +503,55 @@ fails at run time:
   `dataclasses.asdict` form) with every field parsed; use it instead of
   `FusionInstance(**data)`, which passes raw strings into the role-typed fields.
 
+#### Crosschain follows the released contracts
+
+4.0 encodes and decodes the crosschain contracts of the 2026-10-21 contracts
+release (`ipor-abi`: the CCIP and Stargate factories, fuses and NAV pre-hook at
+one CREATE3 address on Arbitrum and HyperEVM). Earlier crosschain deployments
+are not supported: their fuses reject the new calldata, their envelopes fail
+the version check, and their dispatcher `observation()` raises
+`UnsupportedContractVersionError`, so an earlier-generation lane is unreadable
+on the spoke side.
+
+- **Envelopes.** `CODEC_VERSION` is 4 (Stargate), `CCIP_VERSION` 3.
+- **`Command`.** New `min_execution_gas` before `action_data` (0 = the lane's
+  default, at most `MAX_COMMAND_EXECUTION_GAS`); `as_tuple()` / `from_tuple()`
+  have six members and `COMMAND_TUPLE_TYPE` is
+  `(bytes32,uint64,uint64,uint8,uint64,bytes)`.
+- **REQUEST_SHARES.** `Command.request_shares(withdraw_manager, vault, shares,
+  max_fee_shares)`: the fee ceiling in shares is required (`NO_FEE_CEILING` for
+  none).
+- **CCIP supply.** `CcipSendParams.min_delivered` is the delivered-amount floor
+  the supply `enter` carries (0 = none, at most the amount).
+  `CcipCommandType.CANCEL_DEPLOYMENT` cancels an expired dispatcher deployment.
+- **Observations.** `CcipObservation` gains `unpriced_count` and
+  `unpriced_codes` (`unpriced_reason(index)` returns a `TrackedVaultPricing`); the
+  Stargate `Observation` gains `vault_valued` and `unpriced_count`;
+  `LaneObservation` gains `unpriced_count`.
+- **Attestation.** `CrosschainLane.attestation(...)` takes `receipt_at`, the hub's
+  `LaneHubState.last_value_moving_receipt_at` (0 on Stargate). The executor
+  refuses an observation that is not strictly later than its last value-moving
+  receipt; the method raises `ValueError` for it and while a tracked vault is
+  unpriced. New: `LaneHubState.last_value_moving_receipt_at`,
+  `CrosschainLane.last_value_moving_receipt_at()` (`None` on Stargate) and
+  `CcipCrosschainExecutor.last_value_moving_receipt_at`.
+- **Core.** `Call` gains an optional `decode_error` field: a wrapper maps an
+  undecodable answer to a named SDK exception (the earlier-generation
+  `observation()` raises `UnsupportedContractVersionError` this way), and it
+  survives `Call.map()`.
+- **Removed.** `CrosschainDispatcher.pending_request_shares` (neither released
+  dispatcher has it). From the repository: `scripts/crosschain_readiness.py`, the
+  pytest `--run-readiness` option and `readiness` marker, and the examples
+  `crosschain_ccip_usdc_arbitrum_hyperevm.py` and
+  `composed_hypercore_flow_arbitrum_hyperevm.py`, which drove an earlier
+  deployment.
+- **Events and errors.** `CCIP_EVENTS` mirrors the released contracts:
+  `ReturnFinalized` / `LateReturnFinalized` gain `debitedSD`, `SharesRequested`
+  gains `feeShares`, and new events are registered. The crosschain error registry
+  decodes every error the released contracts declare.
+- **Routes.** The released CCIP README requires a route `messageGasLimit` of at
+  least 2.7 M for commands.
+
 ## Errors
 
 Every exception class the SDK defines now derives from `IporFusionError` and is

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev308
+Version: 4.0.0.dev315
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py
@@ -369,10 +369,12 @@ A flash-loan fuse also needs `update_callback_handler(handler, sender, selector)
 
 The full clone → configure → deposit → execute sequence is exercised in [`tests/test_simulate_vault_from_scratch_base.py`](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/tests/test_simulate_vault_from_scratch_base.py).
 
-Custom errors of the crosschain contracts decode by name: importing
-`ipor_fusion.crosschain` registers their signatures (`CROSSCHAIN_ERROR_SIGNATURES`),
-so a simulated or sent call that reverts reads `NavSettledStale(8453)` in
-`SimulationResult.revert_reason` and `TransactionError` instead of a bare selector.
+Custom errors of the IPOR Fusion contracts and the libraries they import
+(OpenZeppelin included) decode by name, so a simulated or sent call that reverts
+reads `AccessManagedUnauthorized(0x...)`, `UnsupportedFuse()` or
+`NavSettledStale(8453)` in `SimulationResult.revert_reason` and `TransactionError`
+instead of a bare selector. Importing `ipor_fusion.crosschain` also registers
+`CROSSCHAIN_ERROR_SIGNATURES`.
 `register_custom_errors([...])` adds your own, and `SimulationResult.raise_for_failure()`
 raises `SimulationError` naming the first failed call.
 
@@ -390,24 +392,11 @@ ever signed or broadcast.
 - [External-state margin leg](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/external_state_margin_leg_base.py) — a vault whose capital
   sits off-chain: typed market-50 substrates, a dual-custodian propose/confirm marking the NAV,
   the scheduled-withdrawal prep an alpha performs, and a mismatched confirmation being rejected.
-- [Crosschain CCIP lifecycle](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/crosschain_ccip_usdc_arbitrum_hyperevm.py) (preview feature) — a vault
-  whose capital works on another chain: supply USDC from an Arbitrum hub to a HyperEVM spoke
-  over CCIP, attest the remote balance with two keys, deposit and redeem on the spoke, recall
-  and claim, driven through `CrosschainLane` and relayed by `CrosschainSimulator`.
-- [Composed HyperCore flow](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/composed_hypercore_flow_arbitrum_hyperevm.py) (preview feature) — the
-  same hub funding a HyperCore vault (market 55) that trades on Hyperliquid Core: the Core leg
-  (bridge, dex transfer, order, close, exit) built from the vault's substrate grants and estimated
-  with `eth_estimateGas` at head (EVM acceptance only, Core executes later), the REDEEM sized by the vault's EVM exit ceiling behind the executor's
-  fee gate, then recall, residual attestation and claim replayed in `CrosschainSimulator` at
-  blocks pinned inside the second live cycle.
-
 ```bash
 export BASE_PROVIDER_URL="https://base-mainnet.g.alchemy.com/v2/YOUR_KEY"
 uv run python examples/simple_aave_v3_supply_base.py
 uv run python examples/advanced_euler_v2_credit_market_base.py
 uv run python examples/external_state_margin_leg_base.py
-uv run python examples/crosschain_ccip_usdc_arbitrum_hyperevm.py  # needs ARBITRUM_PROVIDER_URL and HYPEREVM_PROVIDER_URL
-uv run python examples/composed_hypercore_flow_arbitrum_hyperevm.py  # same two providers
 ```
 
 No RPC key? `BASE_PROVIDER_URL=https://mainnet.base.org` (Base's public RPC) runs the examples out of
@@ -528,12 +517,12 @@ the pilot executors and factories). Pin an exact version if you depend on them.
 | Crosschain fuses (market 54): `StargateCrosschainSupplyFuse`, `StargateCrosschainCommandFuse`, `CcipCrosschainSupplyFuse`, `CcipCrosschainCommandFuse`, `CrosschainClaimFuse`; transport-agnostic bases `CrosschainSupplyFuse` / `CrosschainCommandFuse` with `StargateSendParams` / `CcipSendParams`, plus `Command`, `CrosschainSubstrateLib`, `OptionsBuilder` | `ipor_fusion.crosschain` |
 | HyperCore fuses (market 55): `HyperCoreDepositFuse`, `HyperCoreMarginFuse`, `HyperCoreSendFuse`, `HyperCoreOrderFuse`, `HyperCoreCancelFuse`, `HyperCoreBuilderFeeFuse`, `HyperCoreSubstrates` | `ipor_fusion.hypercore`, with `HyperCoreReader`, `read_hypercore_vault_state` and the event decoders |
 
-The mainnet crosschain POC vault uses a keccak-derived market ID, not 54. Pass
-`market_id=crosschain_market_id("IPOR_FUSION_CROSSCHAIN_USDC_POC_V1")` to `open_lane`
-/ `discover_deployment` for that deployment. Both require it explicitly:
-`discover_deployment` reads the market's executor grants; `open_lane` takes an executor
-address and uses the market ID to find the vault's matching fuses unless they are
-passed.
+The crosschain API supports only the contracts of the 2026-10-21 release; earlier
+deployments are unreadable (`MIGRATION_4.md`). `open_lane` and `discover_deployment`
+take the market ID explicitly (54, or a keccak-derived one from
+`crosschain_market_id(name)` for a vault built with its own): `discover_deployment`
+reads the market's executor grants; `open_lane` takes an executor address and uses the
+market ID to find the vault's matching fuses unless they are passed.
 
 ### Readers (`ipor_fusion.readers`)
 

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/README.md

@@ -320,10 +320,12 @@ A flash-loan fuse also needs `update_callback_handler(handler, sender, selector)
 
 The full clone → configure → deposit → execute sequence is exercised in [`tests/test_simulate_vault_from_scratch_base.py`](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/tests/test_simulate_vault_from_scratch_base.py).
 
-Custom errors of the crosschain contracts decode by name: importing
-`ipor_fusion.crosschain` registers their signatures (`CROSSCHAIN_ERROR_SIGNATURES`),
-so a simulated or sent call that reverts reads `NavSettledStale(8453)` in
-`SimulationResult.revert_reason` and `TransactionError` instead of a bare selector.
+Custom errors of the IPOR Fusion contracts and the libraries they import
+(OpenZeppelin included) decode by name, so a simulated or sent call that reverts
+reads `AccessManagedUnauthorized(0x...)`, `UnsupportedFuse()` or
+`NavSettledStale(8453)` in `SimulationResult.revert_reason` and `TransactionError`
+instead of a bare selector. Importing `ipor_fusion.crosschain` also registers
+`CROSSCHAIN_ERROR_SIGNATURES`.
 `register_custom_errors([...])` adds your own, and `SimulationResult.raise_for_failure()`
 raises `SimulationError` naming the first failed call.
 
@@ -341,24 +343,11 @@ ever signed or broadcast.
 - [External-state margin leg](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/external_state_margin_leg_base.py) — a vault whose capital
   sits off-chain: typed market-50 substrates, a dual-custodian propose/confirm marking the NAV,
   the scheduled-withdrawal prep an alpha performs, and a mismatched confirmation being rejected.
-- [Crosschain CCIP lifecycle](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/crosschain_ccip_usdc_arbitrum_hyperevm.py) (preview feature) — a vault
-  whose capital works on another chain: supply USDC from an Arbitrum hub to a HyperEVM spoke
-  over CCIP, attest the remote balance with two keys, deposit and redeem on the spoke, recall
-  and claim, driven through `CrosschainLane` and relayed by `CrosschainSimulator`.
-- [Composed HyperCore flow](https://github.com/IPOR-Labs/ipor-fusion.py/blob/main/examples/composed_hypercore_flow_arbitrum_hyperevm.py) (preview feature) — the
-  same hub funding a HyperCore vault (market 55) that trades on Hyperliquid Core: the Core leg
-  (bridge, dex transfer, order, close, exit) built from the vault's substrate grants and estimated
-  with `eth_estimateGas` at head (EVM acceptance only, Core executes later), the REDEEM sized by the vault's EVM exit ceiling behind the executor's
-  fee gate, then recall, residual attestation and claim replayed in `CrosschainSimulator` at
-  blocks pinned inside the second live cycle.
-
 ```bash
 export BASE_PROVIDER_URL="https://base-mainnet.g.alchemy.com/v2/YOUR_KEY"
 uv run python examples/simple_aave_v3_supply_base.py
 uv run python examples/advanced_euler_v2_credit_market_base.py
 uv run python examples/external_state_margin_leg_base.py
-uv run python examples/crosschain_ccip_usdc_arbitrum_hyperevm.py  # needs ARBITRUM_PROVIDER_URL and HYPEREVM_PROVIDER_URL
-uv run python examples/composed_hypercore_flow_arbitrum_hyperevm.py  # same two providers
 ```
 
 No RPC key? `BASE_PROVIDER_URL=https://mainnet.base.org` (Base's public RPC) runs the examples out of
@@ -479,12 +468,12 @@ the pilot executors and factories). Pin an exact version if you depend on them.
 | Crosschain fuses (market 54): `StargateCrosschainSupplyFuse`, `StargateCrosschainCommandFuse`, `CcipCrosschainSupplyFuse`, `CcipCrosschainCommandFuse`, `CrosschainClaimFuse`; transport-agnostic bases `CrosschainSupplyFuse` / `CrosschainCommandFuse` with `StargateSendParams` / `CcipSendParams`, plus `Command`, `CrosschainSubstrateLib`, `OptionsBuilder` | `ipor_fusion.crosschain` |
 | HyperCore fuses (market 55): `HyperCoreDepositFuse`, `HyperCoreMarginFuse`, `HyperCoreSendFuse`, `HyperCoreOrderFuse`, `HyperCoreCancelFuse`, `HyperCoreBuilderFeeFuse`, `HyperCoreSubstrates` | `ipor_fusion.hypercore`, with `HyperCoreReader`, `read_hypercore_vault_state` and the event decoders |
 
-The mainnet crosschain POC vault uses a keccak-derived market ID, not 54. Pass
-`market_id=crosschain_market_id("IPOR_FUSION_CROSSCHAIN_USDC_POC_V1")` to `open_lane`
-/ `discover_deployment` for that deployment. Both require it explicitly:
-`discover_deployment` reads the market's executor grants; `open_lane` takes an executor
-address and uses the market ID to find the vault's matching fuses unless they are
-passed.
+The crosschain API supports only the contracts of the 2026-10-21 release; earlier
+deployments are unreadable (`MIGRATION_4.md`). `open_lane` and `discover_deployment`
+take the market ID explicitly (54, or a keccak-derived one from
+`crosschain_market_id(name)` for a vault built with its own): `discover_deployment`
+reads the market's executor grants; `open_lane` takes an executor address and uses the
+market ID to find the vault's matching fuses unless they are passed.
 
 ### Readers (`ipor_fusion.readers`)
 

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/examples/README.md

@@ -38,29 +38,6 @@ transaction.
   brings the margin home and releases it for a user's scheduled withdrawal, then
   demonstrates the executor rejecting a confirmation that does not match its
   proposal.
-- [`crosschain_ccip_usdc_arbitrum_hyperevm.py`](crosschain_ccip_usdc_arbitrum_hyperevm.py) --
-  a vault whose capital works on another chain. Opens a `CrosschainLane` on a
-  live Arbitrum hub vault whose executor has a dispatcher on HyperEVM, then
-  drives the whole lifecycle over CCIP: supply USDC to the spoke, have a
-  proposer and an approver attest the dispatcher's balance into the hub NAV,
-  DEPOSIT into and REDEEM from the spoke vault by command, re-attest, recall
-  the idle to the hub and claim it back into the vault. Both chains run under
-  `eth_simulateV1` and `CrosschainSimulator` relays each CCIP message between
-  them, so it needs an Arbitrum and a HyperEVM archive RPC.
-- [`composed_hypercore_flow_arbitrum_hyperevm.py`](composed_hypercore_flow_arbitrum_hyperevm.py) --
-  the composed flow: the same Arbitrum hub funding a HyperCore vault on
-  HyperEVM (a Plasma Vault that is itself a Hyperliquid Core account) and the
-  trade inside it. Part A builds the Core leg from the vault's market-55
-  substrate grants (bridge EVM -> Core, spot -> perp dex, a limit order and its
-  reduce-only close, dex -> spot, Core -> EVM) and estimates each action with
-  `eth_estimateGas` at head -- six independent previews, EVM acceptance only --
-  with a balance override where the vault holds no USDC and sized to the live
-  Core inventory where the fuse checks a Core balance or dex equity, because
-  `eth_simulateV1` cannot run the HyperCore precompiles.
-  Part B replays the hub legs of the second live cycle in `CrosschainSimulator`
-  at pinned blocks: the REDEEM sized by `read_hypercore_evm_exit_ceiling` behind
-  the executor's maxFee gate, then recall, token return, the residual
-  attestation and the claim. Nothing is signed; it needs the same two RPCs.
 
 ## Prerequisites
 

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/pyproject.toml

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

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/pytest.ini

@@ -4,7 +4,6 @@ log_cli_level = INFO
 addopts = --cov=src/ipor_fusion --cov-report=term-missing --cov-report=xml:coverage.xml
 testpaths = tests
 markers =
-    readiness: live crosschain availability checks (requires --run-readiness; excluded by default)
     sdk: SDK core and fuse tests (integration ones need *_PROVIDER_URL, auto-skip otherwise)
     cli: CLI unit tests (no network required)
     mcp: MCP server tests (no network required)

ipor_fusion-4.0.0.dev315/scripts/fusion_error_signatures.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Regenerate ``src/ipor_fusion/fusion_errors.py`` from an ipor-fusion checkout.
+
+Collects every ``error`` declaration of the Solidity files reachable by import
+from ``contracts/`` (the contracts and the libraries they import, OpenZeppelin
+included, resolved through the checkout's ``foundry.toml`` remappings) and
+writes them as
+canonical ``Name(type,...)`` signatures: enums become ``uint8``, contract,
+interface and library types ``address``, ``uint``/``int`` their 256-bit form.
+Any other parameter type (a struct, a user-defined value type) stops the run,
+because its canonical form needs the compiler.
+
+    uv run python scripts/fusion_error_signatures.py ../ipor-fusion --source <commit>
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+import tomllib
+from pathlib import Path
+
+_OUTPUT = Path(__file__).resolve().parent.parent / "src/ipor_fusion/fusion_errors.py"
+_IMPORT = re.compile(r'^\s*import\s+(?:[^"\']*\s+from\s+)?["\']([^"\']+)["\']', re.M)
+_ERROR = re.compile(r"\berror\s+(\w+)\s*\(([^)]*)\)\s*;")
+_ENUM = re.compile(r"\benum\s+(\w+)")
+_CONTRACT = re.compile(r"\b(?:abstract\s+)?(?:contract|interface|library)\s+(\w+)")
+_ELEMENTARY = re.compile(
+    r"^(address|bool|string|bytes([1-9]|[12]\d|3[0-2])?|u?int(8|16|24|32|40|48|56|64"
+    r"|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224"
+    r"|232|240|248|256)?)$"
+)
+_COMMENTS = re.compile(r"//[^\n]*|/\*.*?\*/", re.S)
+
+
+class _Resolver:
+    """Forge's import resolution: relative paths, then the longest matching
+    remapping, then the checkout root and each ``libs`` directory."""
+
+    def __init__(self, root: Path) -> None:
+        profile = tomllib.loads((root / "foundry.toml").read_text())["profile"]
+        default = profile["default"]
+        pairs = [entry.split("=", 1) for entry in default["remappings"]]
+        self._root = root
+        self._remappings = sorted(pairs, key=lambda pair: -len(pair[0]))
+        self._bases = [root, *(root / lib for lib in default["libs"])]
+
+    def __call__(self, spec: str, importer: Path) -> Path:
+        if spec.startswith("."):
+            return (importer.parent / spec).resolve()
+        for prefix, target in self._remappings:
+            if spec.startswith(prefix):
+                return (self._root / (target + spec.removeprefix(prefix))).resolve()
+        for base in self._bases:
+            if (base / spec).is_file():
+                return (base / spec).resolve()
+        return (self._root / spec).resolve()
+
+
+def _closure(root: Path) -> dict[Path, str]:
+    resolve = _Resolver(root)
+    pending = sorted((root / "contracts").rglob("*.sol"))
+    sources: dict[Path, str] = {}
+    while pending:
+        path = pending.pop()
+        if path in sources:
+            continue
+        if not path.is_file():
+            raise SystemExit(f"unresolved import: {path}")
+        text = _COMMENTS.sub("", path.read_text())
+        sources[path] = text
+        pending.extend(resolve(spec, path) for spec in _IMPORT.findall(text))
+    return sources
+
+
+def _canonical(param: str, enums: set[str], contracts: set[str], where: str) -> str:
+    kind = param.split()[0].split(".")[-1]
+    if kind in ("uint", "int"):
+        return f"{kind}256"
+    if _ELEMENTARY.fullmatch(kind):
+        return kind
+    if kind in enums:
+        return "uint8"
+    if kind in contracts:
+        return "address"
+    raise SystemExit(f"{where}: no canonical form for parameter type {kind!r}")
+
+
+def collect(root: Path) -> list[str]:
+    sources = _closure(root)
+    enums = {name for text in sources.values() for name in _ENUM.findall(text)}
+    contracts = {name for text in sources.values() for name in _CONTRACT.findall(text)}
+    signatures: set[str] = set()
+    for path, text in sources.items():
+        for name, params in _ERROR.findall(text):
+            types = [
+                _canonical(p.strip(), enums, contracts, f"{path}: {name}")
+                for p in params.split(",")
+                if p.strip()
+            ]
+            signatures.add(f"{name}({','.join(types)})")
+    return sorted(signatures)
+
+
+def render(signatures: list[str], source: str) -> str:
+    lines = "\n".join(f'    "{signature}",' for signature in signatures)
+    return f'''"""Custom errors of the IPOR Fusion contracts and the libraries they import
+(OpenZeppelin included), registered by :mod:`ipor_fusion.errors` so revert data
+decodes by name (``AccessManagedUnauthorized(0x...)``, ``UnsupportedFuse()``)
+instead of a bare selector.
+
+Generated by ``scripts/fusion_error_signatures.py`` from ipor-fusion {source};
+do not edit by hand.
+"""
+
+#: ``Name(type,...)`` signatures, sorted; the selector is the keccak of each.
+FUSION_ERROR_SIGNATURES: tuple[str, ...] = (
+{lines}
+)
+'''
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Regenerate fusion_errors.py.")
+    parser.add_argument("checkout", type=Path, help="ipor-fusion checkout")
+    parser.add_argument(
+        "--source", required=True, help="what the checkout is, e.g. a commit"
+    )
+    args = parser.parse_args()
+    signatures = collect(args.checkout.resolve())
+    _OUTPUT.write_text(render(signatures, args.source))
+    print(f"{len(signatures)} signatures -> {_OUTPUT}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/src/ipor_fusion/core/contract.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import Generic, TypeVar, cast
 
 from eth_abi import decode, encode
+from eth_abi.exceptions import DecodingError
 from eth_typing import ChecksumAddress
 from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
@@ -53,6 +54,9 @@ class Call(Generic[T_co]):
     data: bytes
     output_types: Sequence[str] | None = None
     decoder: Callable[..., T_co] | None = None
+    #: Turns an ABI decoding failure of the return data into a named error
+    #: (for a contract build whose return layout differs); ``None`` re-raises.
+    decode_error: Callable[[DecodingError], Exception] | None = None
 
     def __post_init__(self) -> None:
         if self.output_types is not None:
@@ -81,6 +85,7 @@ class Call(Generic[T_co]):
             data=self.data,
             output_types=self.output_types,
             decoder=mapped,
+            decode_error=self.decode_error,
         )
 
     def call(self, ctx: Web3Context, *, block: BlockIdentifier | None = None) -> T_co:
@@ -112,7 +117,12 @@ class Call(Generic[T_co]):
         of `.call(ctx)`, for return data fetched elsewhere (e.g. `Multicall3`)."""
         if not self.output_types:
             raise ValueError("Call.decode() on a write-only Call.")
-        values = tuple(decode(self.output_types, bytes(raw)))
+        try:
+            values = tuple(decode(self.output_types, bytes(raw)))
+        except DecodingError as exc:
+            if self.decode_error is None:
+                raise
+            raise self.decode_error(exc) from exc
         single: object = values[0] if len(values) == 1 else values
         if self.decoder is not None:
             return self.decoder(single)
@@ -163,12 +173,14 @@ class ContractWrapper:
         *args: object,
         output_types: Sequence[str],
         decoder: Callable[..., T] | None = None,
+        decode_error: Callable[[DecodingError], Exception] | None = None,
     ) -> Call[T]:
         return Call(
             to=self._address,
             data=_encode_calldata(signature, *args),
             output_types=output_types,
             decoder=decoder,
+            decode_error=decode_error,
         )
 
     def _write(self, signature: str, *args: object) -> Call[None]:

{ipor_fusion-4.0.0.dev308 → ipor_fusion-4.0.0.dev315}/src/ipor_fusion/crosschain/__init__.py

@@ -110,6 +110,8 @@ from ipor_fusion.crosschain.messages import (
     CCIP_VERSION,
     CODEC_VERSION,
     EMPTY_COMMAND,
+    MAX_COMMAND_EXECUTION_GAS,
+    NO_FEE_CEILING,
     BusinessAction,
     CcipMsgType,
     Command,
@@ -117,6 +119,7 @@ from ipor_fusion.crosschain.messages import (
     CrosschainTransportKind,
     DeploymentStatus,
     MsgType,
+    TrackedVaultPricing,
     decode_ccip_envelope,
     decode_command,
     decode_envelope,
@@ -254,6 +257,9 @@ __all__ = [
     "CrosschainTransportKind",
     "DeploymentStatus",
     "EMPTY_COMMAND",
+    "MAX_COMMAND_EXECUTION_GAS",
+    "NO_FEE_CEILING",
+    "TrackedVaultPricing",
     "EVMTokenAmount",
     "EnforcedOptionParam",
     "ExecutorInitParams",