ipor-fusion 4.0.0.dev144__tar.gz → 4.0.0.dev149__tar.gz

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/AGENTS.md

@@ -441,7 +441,8 @@ are not validated.
 ## Domain rules (verified against the contracts)
 
 - `fetch_vault_data(ctx, vault, *, block=, lending=, metadata=)` is the snapshot:
-  it resolves one block (``block``, else a numeric `ctx.default_block`, else latest),
+  it resolves one block (``block``, else `ctx.default_block` with a tag or hash resolved to its
+  number, else latest),
   runs every read on `ctx.at_block(block)` (log scans end there too) and returns
   everything validation and the ``vault info`` document need, so neither reads the
   chain. The chain is `ctx.chain_id`; ``lending=False`` skips lending health, the

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/MIGRATION_4.md

@@ -94,7 +94,7 @@ placeholder wrapper.
   `aggregate3(calls)` still returns the raw `Call`), `VaultSimulator`,
   `CrosschainSimulator` and `OracleMappingReader(ctx, oracle)`.
 - Resolvers that probe the chain stay eager and return context-free wrappers:
-  `price_oracle_middleware(ctx, oracle)`, `resolve_access_manager(ctx, vault)`,
+  `price_oracle_middleware(ctx, address)`, `resolve_access_manager(ctx, vault)`,
   `ExternalStateExecutor.for_vault(ctx, vault)`. A resolved oracle carries the ABI
   found on that chain and block; resolve again for another one.
 - Crosschain lanes own both contexts: `CcipLane` / `StargateLane` take `hub_ctx=` and
@@ -113,9 +113,9 @@ placeholder wrapper.
   do not see a CCIP recall or tell a parked command from a pending one. `CrosschainTransport.executor(address)`
   and `.dispatcher(address)` no longer take a context.
 - Chain-bound decoding takes the chain explicitly:
-  `ExternalStateExecutor.pending_proposals(account, *, chain_id)`,
+  `ExternalStateExecutor.pending_proposals(balance_account, *, chain_id)`,
   `parse_balance_proposed(log, *, chain_id)` and
-  `find_balance_proposed(logs, account=None, *, chain_id)` require it (3.x fell back
+  `find_balance_proposed(logs, balance_account=None, *, chain_id)` require it (3.x fell back
   to the wrapper's context). The decoder captures it, so `.call(ctx)`, `Multicall3`
   and `VaultSimulator.observe` stamp the same hash for the same bytes, whatever
   context executes them. Pass `ctx.chain_id` for the chain you read from.
@@ -134,7 +134,7 @@ placeholder wrapper.
 | `call.build_transaction(block=b)`, `call.estimate_gas(block=b)` | `call.build_transaction(ctx, block=b)`, `call.estimate_gas(ctx, block=b)` |
 | `call.ctx` | gone: keep the context yourself |
 | `Multicall3(ctx, address)` | `Multicall3(ctx, address=address)` |
-| `executor.pending_proposals(account)` | `executor.pending_proposals(account, chain_id=ctx.chain_id)` |
+| `executor.pending_proposals(balance_account)` | `executor.pending_proposals(balance_account, chain_id=ctx.chain_id)` |
 | `executor.parse_balance_proposed(log)` / `find_balance_proposed(logs)` | `...(log, chain_id=...)` / `...(logs, chain_id=...)` |
 | `CcipLane(executor=, dispatcher=, spoke_chain_id=, ...)` | `CcipLane(hub_ctx=, spoke_ctx=, executor=, dispatcher=, ...)` (same for `StargateLane`) |
 | `transport.executor(ctx, address)` / `transport.dispatcher(ctx, address)` | `transport.executor(address)` / `transport.dispatcher(address)` |
@@ -174,7 +174,8 @@ The vault read is one pinned snapshot, and the chain is always the context's:
 
 - `fetch_vault_data(ctx, vault, *, block=None, lending=True, metadata=True)` takes
   the vault address (not a `PlasmaVault`) and no `chain_id`. It resolves one block
-  (`block`, else a numeric `ctx.default_block`, else the latest) and runs every
+  (`block`, else `ctx.default_block`, with a `safe` / `finalized` tag or a block hash
+  resolved to its number, else the latest) and runs every
   read, log scans included, on `ctx.at_block(block)`; `ctx` is not modified. In 3.x
   `block_number` only selected the block reported in `VaultData`, and the reads ran
   wherever `ctx` pointed. The old `chain_id=0` switch is `lending=False`;
@@ -289,6 +290,8 @@ fails at run time:
   keyword.
 - `encode_oft_compose_msg(*, nonce=, src_eid=, amount_ld=, compose_msg=)` takes
   keyword arguments only.
+- `build_oracle_mapping(ctx, vault, *, effective_block, max_depth=6)` takes
+  `effective_block` and `max_depth` by keyword.
 - The vault parameter is named `vault` throughout: `validate_vault`,
   `fetch_deployment_info`, `fetch_vault_lending_health`, `build_oracle_mapping`,
   `read_external_state`, `ExternalStateExecutor.for_vault`, `read_hypercore_nav`,
@@ -434,8 +437,8 @@ are cached in a `ContractCache`, injected instead of always written to `~/.cache
   explicitly (default: the file cache); pass `cache=ctx.cache` to share the
   context's policy. The CLI's text and JSON output name contracts through the
   context's cache.
-- `build_vault_info_json(data)` without `resolve_name` names no contract (every
-  `contract` is `"?"`) instead of reading names from the on-disk cache; pass
+- `build_vault_info_json(data)` without `resolve_name` names no contract (fuse and
+  balance-fuse entries show `contract` as `"?"`, substrate entries omit it) instead of reading names from the on-disk cache; pass
   `resolve_name=partial(get_contract_name, chain_id, api_key=..., cache=ctx.cache)`
   for the CLI's document.
 - `ipor_fusion.cache` is a public module now and exports `ContractCache`,
@@ -536,13 +539,19 @@ converted amounts `Amount`. A custom `VaultState` annotates the same.
 `PlasmaVault.total_supply()`, `balance_of()` and `get_total_supply_cap()` return
 `Shares` (vault shares), and `transfer` / `approve` / `transfer_from` /
 `set_total_supply_cap` take `Shares`; `ERC20` keeps `Amount`.
+`Reconciliation` amounts (`balance_fuses_total`, `underlying_on_vault`,
+`erc20_direct_total`, `sum`, `on_chain_total_assets`, `delta`,
+`pending_withdrawals`, `implied_market_total`, `market_storage_divergence`) are
+`Amount`. `FusionInstance.asset_decimals` / `underlying_token_decimals` are
+`Decimals`, and `CloneArgs.redemption_delay_seconds` is a `Period`.
+`VaultSimulator.current_time` is a `Timestamp`.
 
 **Vault data and helpers.** `ensure_supported_chain` takes `ChainId`.
 `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
-typed for `str` still fits). Market-keyed data is keyed by `MarketId`:
+fits), and the `resolve_name` callback receives one (a callback typed for `str`
+still fits). Market-keyed data is keyed by `MarketId`:
 `VaultData.market_substrates`, `dependency_graph`, `morpho_positions`,
 `aave_positions`, `market_balances`; the `VaultState` protocol,
 `fetch_vault_lending_health`, `fetch_unpriceable_priced_tokens` and the
@@ -566,9 +575,13 @@ The Uniswap V3 / Ramses V2 position events' `version`, `sender` and `recipient`
 `MarketId`; `Erc20Holding.address` is `HexAddress`, and `SubstrateInfo.address` is
 `HexAddress | None`. `LegacyPriceOracleMiddleware` takes `base_currency_decimals:
 Decimals`, and `PriceOracleMiddleware.base_currency_decimals()` returns
-`Call[Decimals]`. `get_logs_adaptive(chain_id=)` and `LogSource.get_logs` take
-`ChainId`; `quote_ccip_native_fee(block=)` and
+`Call[Decimals]`. `get_logs_adaptive(chain_id=)` takes `ChainId | None` and
+`LogSource.get_logs` a `ChainId`; `quote_ccip_native_fee(block=)` and
 `OracleMappingReader.asset_source_events` take a `BlockIdentifier`.
+`OracleMappingReader.token_decimals`, `feed_decimals` and `vault_decimals` return
+`Decimals | None` and `vault_convert_to_assets` an `Amount | None`;
+`AaveV4OracleReader.decimals()` returns `Call[Decimals]`; and `OraclePrice.decimals`, `OracleNode.decimals` and
+`OracleAsset.decimals` are `Decimals` (`| None` on the nodes).
 
 **Address roles.** `PlasmaVault(address)`,
 `validate_vault`, `fetch_deployment_info`, the HyperCore, lending-health and
@@ -602,7 +615,8 @@ by `ChainId` (`HYPEREVM_CHAIN_ID` is one) and `explorer.SUPPORTED_CHAINS` is a
 type-checks; `PUBLIC_ALLOCATOR_ADDRESSES` values are `ChecksumAddress`.
 
 **Markets, substrates and access.** Every `IporFusionMarkets` member is a `MarketId`.
-`decode_substrate`, `market_name`, `format_market_label` take `MarketId`.
+`market_name` and `format_market_label` take `MarketId`, `decode_substrate` a
+`MarketId | None`.
 `AccessManager.has_role`, `grant_role`, `revoke_role` and `read_accounts_with_role`
 take `RoleId | Roles`; `RoleAccount.role_id` is `RoleId`.
 
@@ -619,6 +633,12 @@ takes a `ChecksumAddress`, and `build_morpho_blue_market_json` takes
 records is `ChecksumAddress`; optional ones (`curator`, `guardian`, `fee_recipient`,
 `performance_fee_recipient`, `management_fee_recipient`, `inner_vault`,
 `VaultFlowCap.admin`, the `VaultV2Cap` market params) are `ChecksumAddress | None`.
+Token amounts on those records are `Amount` (`VaultFlowCap.max_in` / `max_out`, the
+`VaultAllocation`, `VaultV1Info`, `VaultV1MarketAllocation`, `VaultV2Info` and
+`MorphoApiMarket` asset amounts and caps, `VaultV2Cap.absolute_cap` / `allocation`
+/ `room`, `VaultV2Adapter.assets`, `cap_room`), token decimals are `Decimals` and
+`MorphoApiMarket.timestamp` is a `Timestamp`. `lltv`, `fee_wad`,
+`relative_cap_wad` and `fee_wei` stay `int`.
 
 **Crosschain.** The executor, dispatcher and factory wrappers, the lanes and
 `StargateCrosschainCommandFuse.enter(request_id=)` take the crosschain ids above, and
@@ -630,7 +650,25 @@ on CCIP, `active_return` → `OperationId`, `asset_id`, `tracked_position_set_ha
 `CcipObservation`, `OutboundMessage`, `CcipMessageSent`, `Any2EVMMessage`,
 `VerifierResult`, `Packet.guid`, `TaxiMessage`, `StargateChain`; and the helpers
 `fetch_verifier_result(message_id=)`, `lz_receive_calldata(guid=)` and
-`lz_compose_calldata(guid=)` take a `MessageId`. Decoded event values
+`lz_compose_calldata(guid=)` take a `MessageId`. Lane times are typed:
+`last_approved_observed_at()` returns a `Timestamp` and `staleness_max()` (with
+`STALENESS_MAX` / `BALANCE_STALENESS_MAX` on the executors) a `Period`, and so do
+the `LaneHubState` fields; `attestation(remote_timestamp=, expiry=)` and
+`BalanceObservation` take `Timestamp`, `needs_attestation(now=, margin=)` a
+`Timestamp` and a `Period`. The other durations are `Period` too: the executors'
+`min_update_interval()`, `transfer_staleness_max()` and `deployment_ttl()`, both
+factories' `config_delay()`, and the time fields of `ExecutorInitParams` and
+`SafetyConfig` (`rescue_delay`, the staleness fields, `min_update_interval`,
+`deployment_ttl`); `in_flight_since()`, `last_approval_at()`, `oldest_pending_at()`
+and `pending_deployment_created_at()` return a `Timestamp`. Decimals are
+`Decimals`: `local_decimals()` / `shared_decimals()` on the executor and dispatcher,
+`CcipChain.local_decimals`, `StargateChain.local_decimals` / `shared_decimals`, the
+`shared_decimals` of `CcipCrosschainFactory.asset_config()`, `schedule_asset` and
+`execute_asset`. Token amounts are `Amount` (`EVMTokenAmount.amount`,
+`TokenTransferV1.amount`, `TaxiMessage.amount_sd`, `OutboundMessage.token_amount`,
+`StargateChain.to_local_decimals`), and `pending_request_shares()` returns
+`Shares`. Counters, sequences, epochs, versions, bps and gas limits stay `int`.
+Decoded event values
 (`ccip_events` → `CcipEvent.values`) stay a generic mapping: convert a value
 before passing it on.
 
@@ -653,25 +691,35 @@ fuse's `eid=` take it (`LayerZeroEid(30101)`). CCIP chain selectors are
 `read_hypercore_transfer_snapshot` and the helpers `system_address`,
 `precompile_index_of`, `perp_dex_of`, `is_native_perp_asset`, `is_hip3_asset` take the
 HyperCore ids; `HyperCorePerpAssetInfo`, `HyperCorePerpMarket`, `HyperCoreSpotLeg`,
-`HyperCorePendingState` and `HyperCoreTransferSnapshot` carry them.
+`HyperCorePendingState` and `HyperCoreTransferSnapshot` carry them. Token decimals
+(`HyperCoreTokenInfo.sz_decimals` / `wei_decimals` / `evm_extra_wei_decimals`,
+`HyperCorePerpAssetInfo.sz_decimals`, `HyperCoreSpotLeg.wei_decimals`) are
+`Decimals`, and `HyperCorePendingState.pending_until` / `current_timestamp` are
+`Timestamp`; Core amounts, positions, WAD values and L1 block numbers stay `int`.
 
 **External state.** `ExternalStateExecutor.proposal_hash` returns and `confirm_balance`
 takes a `ProposalHash`; `BalanceProposal.proposal_hash` is a `ProposalHash`;
-`ExternalStateEvent.transaction_hash` is a `TxHash`.
+`ExternalStateEvent.transaction_hash` is a `TxHash | None`.
 `ExternalStateVaultState.last_checked_custodian_timestamp`,
 `BalanceFuseSnapshot.last_custodian_update_timestamp`, `BalanceProposal.proposed_at`,
 `last_updated()` and `get_oldest_update_timestamp()` are web3's `Timestamp`, and
 `ExternalStateExecutor.proposal_hash(proposed_at=)` takes one.
+`ExternalStateExecutor.staleness_max()` / `min_update_interval()` return a `Period`,
+and `ExternalStateSubstrates.staleness_max` / `min_update_interval` take one
+(`Period.DAY`).
 
-**Errors and explorer.** `TransactionError(tx_hash=)` takes a `TxHash`,
+**Errors and explorer.** `TransactionError(tx_hash=)` takes a `TxHash | None`,
 `LogScanError(address=)` a `ChecksumAddress`; `get_revert_reason` takes a `TxHash`;
 `get_deployment_tx` returns a `TxHash` (a malformed hash from Etherscan is reported
 as the error `malformed-tx-hash`).
 
 **MCP response models** (Python constructors only; the JSON schemas are unchanged
 except as listed under [Behavior changes](#behavior-changes)): `chain_id` fields are
-`ChainId`, `role_id` `RoleId`, `market_id` `MarketId`. Calling an MCP tool function
-directly from Python takes `ChainId`.
+`ChainId`, `role_id` `RoleId`, `market_id` `MarketId` (except
+`LendingMarketHealth.market_id`, which stays `str | int`: a Morpho market id is a
+string). Calling an MCP tool function
+directly from Python takes `ChainId`. Their amount, decimals and time fields stay
+`int`: they are JSON output models, and the SDK values above fit them unchanged.
 
 ## Behavior changes
 

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev144
+Version: 4.0.0.dev149
 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.dev144 → ipor_fusion-4.0.0.dev149}/examples/composed_hypercore_flow_arbitrum_hyperevm.py

@@ -68,7 +68,7 @@ from typing import Any, NamedTuple
 from eth_abi.abi import encode as abi_encode
 from eth_utils import keccak
 from web3 import Web3
-from web3.types import BlockIdentifier, RPCEndpoint
+from web3.types import BlockIdentifier, RPCEndpoint, Timestamp
 
 from ipor_fusion import (
     ERC20,
@@ -110,6 +110,7 @@ from ipor_fusion.market_ids import IporFusionMarkets
 from ipor_fusion.types import (
     Amount,
     ChainId,
+    Decimals,
     HyperCoreAsset,
     HyperCoreClientOrderId,
     MarketId,
@@ -649,14 +650,14 @@ def _transport() -> CcipTransport:
                 ARBITRUM_CCIP_SELECTOR,
                 ARBITRUM_CCIP_ROUTER,
                 ARBITRUM_USDC,
-                6,
+                Decimals(6),
             ),
             CcipChain(
                 HYPEREVM_CHAIN_ID,
                 HYPEREVM_CCIP_SELECTOR,
                 HYPEREVM_CCIP_ROUTER,
                 HYPEREVM_USDC,
-                6,
+                Decimals(6),
             ),
         )
     )
@@ -791,7 +792,7 @@ def _attest(flow: _Tail, tag: str, observation_label: str, *, hub_idle: int = 0)
         observation,
         remote_block=flow.spoke.current_block_number,
         remote_timestamp=flow.spoke.current_time,
-        expiry=flow.hub.current_time + PROPOSAL_TTL,
+        expiry=Timestamp(flow.hub.current_time + PROPOSAL_TTL),
     )
     # SIMULATION ONLY: two keyless addresses driven from one process; live
     # they are two signers, which is the point of the two-key design.

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/examples/crosschain_ccip_usdc_arbitrum_hyperevm.py

@@ -66,6 +66,7 @@ import sys
 from typing import NamedTuple
 
 from web3 import Web3
+from web3.types import Timestamp
 
 from ipor_fusion import (
     ERC20,
@@ -85,7 +86,7 @@ from ipor_fusion import (
     parse_plasma_vault_address,
 )
 from ipor_fusion.market_ids import IporFusionMarkets
-from ipor_fusion.types import Amount, ChainId, MarketId, Period, Shares
+from ipor_fusion.types import Amount, ChainId, Decimals, MarketId, Period, Shares
 
 log = logging.getLogger("crosschain_ccip_usdc_arbitrum_hyperevm")
 
@@ -222,14 +223,14 @@ def transport() -> CcipTransport:
                 ARBITRUM_CCIP_SELECTOR,
                 ARBITRUM_CCIP_ROUTER,
                 ARBITRUM_USDC,
-                6,
+                Decimals(6),
             ),
             CcipChain(
                 HYPEREVM_CHAIN_ID,
                 HYPEREVM_CCIP_SELECTOR,
                 HYPEREVM_CCIP_ROUTER,
                 HYPEREVM_USDC,
-                6,
+                Decimals(6),
             ),
         )
     )
@@ -431,7 +432,7 @@ def _attest(flow: _Flow, tag: str, observation_label: str, *, hub_idle: int = 0)
         observation,
         remote_block=flow.spoke.current_block_number,
         remote_timestamp=flow.spoke.current_time,
-        expiry=flow.hub.current_time + PROPOSAL_TTL,
+        expiry=Timestamp(flow.hub.current_time + PROPOSAL_TTL),
     )
     # SIMULATION ONLY: the proposer and the approver are two addresses with no
     # keys here, driven from one process. Live they are two separate signers,

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/pyproject.toml

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

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/cli/vault_cmd.py

@@ -449,7 +449,9 @@ def oracle_mapping(
         raise click.UsageError(str(exc)) from exc
 
     try:
-        mapping = build_oracle_mapping(ctx, vault_address, effective_block, max_depth)
+        mapping = build_oracle_mapping(
+            ctx, vault_address, effective_block=effective_block, max_depth=max_depth
+        )
     except UnsupportedVaultVersionError as exc:
         raise click.ClickException(str(exc)) from exc
 

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/core/external_state_executor.py

@@ -35,6 +35,7 @@ from ipor_fusion.types import (
     ZERO_ADDRESS,
     Amount,
     ChainId,
+    Period,
     PlasmaVaultAddress,
     ProposalHash,
 )
@@ -371,10 +372,10 @@ class ExternalStateExecutor(ContractWrapper):
             "getOldestUpdateTimestamp()", output_types=["uint256"], decoder=Timestamp
         )
 
-    def staleness_max(self) -> Call[int]:
+    def staleness_max(self) -> Call[Period]:
         """Seconds after which a custodian report counts as stale: the pre-hook
         blocks the vault's gated user operations past it."""
-        return self._view("stalenessMax()", output_types=["uint256"])
+        return self._view("stalenessMax()", output_types=["uint256"], decoder=Period)
 
     def big_change_bps(self) -> Call[int]:
         """Basis points of total-balance change between two custodian updates
@@ -382,13 +383,16 @@ class ExternalStateExecutor(ContractWrapper):
         return self._view("bigChangeBps()", output_types=["uint256"])
 
     def dust_threshold(self) -> Call[int]:
-        """Underlying units below which a leftover is dust, not a balance."""
+        """Dust threshold as a percent of one underlying token (100 = one whole
+        token); a leftover below it is dust, not a balance."""
         return self._view("dustThreshold()", output_types=["uint256"])
 
-    def min_update_interval(self) -> Call[int]:
+    def min_update_interval(self) -> Call[Period]:
         """Seconds a balance account must wait between two custodian
         updates."""
-        return self._view("minUpdateInterval()", output_types=["uint256"])
+        return self._view(
+            "minUpdateInterval()", output_types=["uint256"], decoder=Period
+        )
 
     def nonce(self) -> Call[int]:
         """Monotonic proposal nonce, incremented on every `proposeBalance`.

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/core/fusion_factory.py

@@ -35,6 +35,7 @@ from web3.types import TxReceipt
 from ipor_fusion.core.contract import Call, ContractWrapper
 from ipor_fusion.types import (
     AccessManagerAddress,
+    Decimals,
     Period,
     PlasmaVaultAddress,
     parse_access_manager_address,
@@ -51,7 +52,7 @@ class CloneArgs:
     asset_name: str
     asset_symbol: str
     underlying_token: ChecksumAddress
-    redemption_delay_seconds: int
+    redemption_delay_seconds: Period
     owner: ChecksumAddress
     dao_fee_package_index: int
 
@@ -64,10 +65,10 @@ class FusionInstance:
     version: int
     asset_name: str
     asset_symbol: str
-    asset_decimals: int
+    asset_decimals: Decimals
     underlying_token: ChecksumAddress
     underlying_token_symbol: str
-    underlying_token_decimals: int
+    underlying_token_decimals: Decimals
     initial_owner: ChecksumAddress
     plasma_vault: PlasmaVaultAddress
     plasma_vault_base: ChecksumAddress
@@ -118,10 +119,10 @@ _INSTANCE_FIELDS: dict[str, Callable[[Any], Any]] = {
     "version": _integer,
     "asset_name": _text,
     "asset_symbol": _text,
-    "asset_decimals": _integer,
+    "asset_decimals": lambda value: Decimals(_integer(value)),
     "underlying_token": _address,
     "underlying_token_symbol": _text,
-    "underlying_token_decimals": _integer,
+    "underlying_token_decimals": lambda value: Decimals(_integer(value)),
     "initial_owner": _address,
     "plasma_vault": lambda value: parse_plasma_vault_address(_text(value)),
     "plasma_vault_base": _address,
@@ -185,10 +186,10 @@ def _fusion_instance_decoder(values: tuple) -> FusionInstance:
         version=version,
         asset_name=asset_name,
         asset_symbol=asset_symbol,
-        asset_decimals=asset_decimals,
+        asset_decimals=Decimals(asset_decimals),
         underlying_token=addr(underlying_token),
         underlying_token_symbol=underlying_token_symbol,
-        underlying_token_decimals=underlying_token_decimals,
+        underlying_token_decimals=Decimals(underlying_token_decimals),
         initial_owner=addr(initial_owner),
         plasma_vault=PlasmaVaultAddress(addr(plasma_vault)),
         plasma_vault_base=addr(plasma_vault_base),
@@ -347,10 +348,10 @@ class FusionFactory(ContractWrapper):
             version=int(values[1]),
             asset_name=values[2],
             asset_symbol=values[3],
-            asset_decimals=int(values[4]),
+            asset_decimals=Decimals(int(values[4])),
             underlying_token=Web3.to_checksum_address(values[5]),
             underlying_token_symbol=values[6],
-            underlying_token_decimals=int(values[7]),
+            underlying_token_decimals=Decimals(int(values[7])),
             initial_owner=Web3.to_checksum_address(values[8]),
             plasma_vault=PlasmaVaultAddress(Web3.to_checksum_address(values[9])),
             plasma_vault_base=Web3.to_checksum_address(values[10]),
@@ -390,7 +391,7 @@ class FusionFactory(ContractWrapper):
             asset_name=asset_name,
             asset_symbol=asset_symbol,
             underlying_token=Web3.to_checksum_address(underlying_token),
-            redemption_delay_seconds=int(redemption_delay_seconds),
+            redemption_delay_seconds=Period(redemption_delay_seconds),
             owner=Web3.to_checksum_address(owner),
             dao_fee_package_index=int(dao_fee_package_index),
         )

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/core/simulation.py

@@ -10,7 +10,7 @@ from eth_typing import ChecksumAddress
 from eth_utils import keccak
 from hexbytes import HexBytes
 from web3 import Web3
-from web3.types import BlockIdentifier, Nonce, RPCEndpoint
+from web3.types import BlockIdentifier, Nonce, RPCEndpoint, Timestamp
 from web3.utils.address import get_create_address
 
 from ipor_fusion.core.contract import Call, _encode_calldata
@@ -221,13 +221,13 @@ class VaultSimulator:
         return any(block.calls for block in self._blocks)
 
     @property
-    def current_time(self) -> int:
+    def current_time(self) -> Timestamp:
         """Timestamp of the latest sent block or an explicit pending time.
 
         A pending block without an explicit time will run 12 seconds later
         once it contains a call.
         """
-        return self._current_time()
+        return Timestamp(self._current_time())
 
     @property
     def current_block_number(self) -> int:

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/crosschain/ccip/codec.py

@@ -21,7 +21,7 @@ from web3 import Web3
 
 from ipor_fusion.core.contract import _encode_calldata
 from ipor_fusion.crosschain.logs import log_bytes
-from ipor_fusion.types import CcipChainSelector, MessageId
+from ipor_fusion.types import Amount, CcipChainSelector, MessageId
 
 #: topic0 of ``OnRamp 2.0.0``'s ``CCIPMessageSent``; ``destChainSelector``,
 #: ``sender`` and ``messageId`` are indexed.
@@ -72,7 +72,7 @@ class TokenTransferV1:
     """``MessageV1Codec.TokenTransferV1``. Address fields are raw bytes as
     encoded for the destination chain (20 bytes on EVM)."""
 
-    amount: int
+    amount: Amount
     source_pool_address: bytes
     source_token_address: bytes
     dest_token_address: bytes
@@ -84,7 +84,7 @@ class TokenTransferV1:
         if reader.uint(1) != _MESSAGE_VERSION:
             raise ValueError("unsupported CCIP token transfer version")
         return cls(
-            amount=reader.uint(32),
+            amount=Amount(reader.uint(32)),
             source_pool_address=reader.prefixed(1),
             source_token_address=reader.prefixed(1),
             dest_token_address=reader.prefixed(1),
@@ -207,7 +207,7 @@ class EVMTokenAmount:
     """``CcipClient.EVMTokenAmount``."""
 
     token: ChecksumAddress
-    amount: int
+    amount: Amount
 
 
 @dataclass(frozen=True, slots=True)

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/crosschain/ccip/contracts.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 from eth_abi import encode
 from eth_typing import ChecksumAddress
 from eth_utils import keccak
+from web3.types import Timestamp
 
 from ipor_fusion.core.contract import Call
 from ipor_fusion.crosschain.contracts import (
@@ -24,8 +25,10 @@ from ipor_fusion.types import (
     CcipChainSelector,
     ChainId,
     CommandId,
+    Decimals,
     MessageId,
     OperationId,
+    Period,
     PlasmaVaultAddress,
     PositionSetHash,
     ProposalId,
@@ -92,11 +95,11 @@ class SafetyConfig:
     rescue_guardian: ChecksumAddress
     balance_proposer: ChecksumAddress
     balance_approver: ChecksumAddress
-    rescue_delay: int
-    balance_staleness_max: int
+    rescue_delay: Period
+    balance_staleness_max: Period
     big_change_bps: int
-    min_update_interval: int
-    transfer_staleness_max: int
+    min_update_interval: Period
+    transfer_staleness_max: Period
 
     def as_tuple(self) -> tuple:
         return (
@@ -143,8 +146,10 @@ class CcipCrosschainExecutor(CrosschainExecutor):
     def decimal_conversion_rate(self) -> Call[int]:
         return self._view("DECIMAL_CONVERSION_RATE()", output_types=["uint256"])
 
-    def balance_staleness_max(self) -> Call[int]:
-        return self._view("BALANCE_STALENESS_MAX()", output_types=["uint256"])
+    def balance_staleness_max(self) -> Call[Period]:
+        return self._view(
+            "BALANCE_STALENESS_MAX()", output_types=["uint256"], decoder=Period
+        )
 
     def ccip_route(self, chain_id: ChainId) -> Call[CcipRouteConfig]:
         return self._view(
@@ -228,8 +233,13 @@ class CcipCrosschainExecutor(CrosschainExecutor):
             decoder=CommandStatus,
         )
 
-    def oldest_pending_at(self, chain_id: ChainId) -> Call[int]:
-        return self._view("oldestPendingAt(uint256)", chain_id, output_types=["uint64"])
+    def oldest_pending_at(self, chain_id: ChainId) -> Call[Timestamp]:
+        return self._view(
+            "oldestPendingAt(uint256)",
+            chain_id,
+            output_types=["uint64"],
+            decoder=Timestamp,
+        )
 
     def pending_transfer_count(self, chain_id: ChainId) -> Call[int]:
         return self._view(
@@ -387,13 +397,13 @@ class CcipCrosschainFactory(CrosschainFactory):
 
     def asset_config(
         self, asset_id: AssetId
-    ) -> Call[tuple[ChecksumAddress, int, bool]]:
+    ) -> Call[tuple[ChecksumAddress, Decimals, bool]]:
         """``(token, sharedDecimals, enabled)`` for an asset id."""
         return self._view(
             "assetConfig(bytes32)",
             asset_id,
             output_types=["address", "uint8", "bool"],
-            decoder=lambda v: (_address(v[0]), int(v[1]), bool(v[2])),
+            decoder=lambda v: (_address(v[0]), Decimals(v[1]), bool(v[2])),
         )
 
     def is_dispatcher(self, dispatcher: ChecksumAddress) -> Call[bool]:
@@ -412,22 +422,23 @@ class CcipCrosschainFactory(CrosschainFactory):
 
     def pending_deployment_created_at(
         self, executor: ChecksumAddress, dst_chain_id: ChainId
-    ) -> Call[int]:
+    ) -> Call[Timestamp]:
         return self._view(
             "pendingDeploymentCreatedAt(address,uint256)",
             executor,
             dst_chain_id,
             output_types=["uint64"],
+            decoder=Timestamp,
         )
 
     def owner(self) -> Call[ChecksumAddress]:
         return self._view("OWNER()", output_types=["address"], decoder=_address)
 
-    def config_delay(self) -> Call[int]:
+    def config_delay(self) -> Call[Period]:
         """Timelock of every scheduled asset, factory route and dispatcher
         deployment gas limit: 24 hours in source, 300 seconds on the test
         builds."""
-        return self._view("CONFIG_DELAY()", output_types=["uint256"])
+        return self._view("CONFIG_DELAY()", output_types=["uint256"], decoder=Period)
 
     def executor_creation_code_hash(self) -> Call[bytes]:
         """keccak of the executor creation code the factory stores. It tells
@@ -466,7 +477,7 @@ class CcipCrosschainFactory(CrosschainFactory):
         )
 
     def schedule_asset(
-        self, asset_id: AssetId, token: ChecksumAddress, shared_decimals: int
+        self, asset_id: AssetId, token: ChecksumAddress, shared_decimals: Decimals
     ) -> Call[None]:
         """Owner-only; executable after ``config_delay`` with the same arguments."""
         return self._write(
@@ -474,7 +485,7 @@ class CcipCrosschainFactory(CrosschainFactory):
         )
 
     def execute_asset(
-        self, asset_id: AssetId, token: ChecksumAddress, shared_decimals: int
+        self, asset_id: AssetId, token: ChecksumAddress, shared_decimals: Decimals
     ) -> Call[None]:
         return self._write(
             "executeAsset(bytes32,address,uint8)", asset_id, token, shared_decimals

{ipor_fusion-4.0.0.dev144 → ipor_fusion-4.0.0.dev149}/src/ipor_fusion/crosschain/ccip/lane.py

@@ -22,7 +22,7 @@ from ipor_fusion.crosschain.fuses.ccip import (
 )
 from ipor_fusion.crosschain.lane import CrosschainLane, LaneFuses, LaneObservation
 from ipor_fusion.crosschain.messages import CommandStatus, CrosschainTransportKind
-from ipor_fusion.types import Amount, ProposalId
+from ipor_fusion.types import Amount, Period, ProposalId
 
 
 class CcipLane(CrosschainLane):
@@ -89,7 +89,7 @@ class CcipLane(CrosschainLane):
             ),
         )
 
-    def staleness_max(self) -> Call[int]:
+    def staleness_max(self) -> Call[Period]:
         return self.executor.balance_staleness_max()
 
     def default_send(self, *, token: bool) -> CcipSendParams: