olas-operate-middleware 0.13.10__tar.gz → 0.14.0__tar.gz

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: olas-operate-middleware
-Version: 0.13.10
+Version: 0.14.0
 Summary: 
 License-File: LICENSE
 Author: David Vilela

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/bridge/bridge_manager.py

@@ -369,9 +369,9 @@ class BridgeManager:
         status_json = self.get_status_json(bundle.id)
         status_json.update(
             {
-                "balances": balances,
-                "bridge_refill_requirements": bridge_refill_requirements,
-                "bridge_total_requirements": bridge_total_requirements,
+                "balances": balances.json,
+                "bridge_refill_requirements": bridge_refill_requirements.json,
+                "bridge_total_requirements": bridge_total_requirements.json,
                 "expiration_timestamp": bundle.timestamp + self.bundle_validity_period,
                 "is_refill_required": is_refill_required,
             }

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/bridge/providers/provider.py

@@ -44,6 +44,7 @@ from operate.constants import (
 from operate.ledger import get_default_ledger_api, update_tx_with_gas_pricing
 from operate.operate_types import Chain, ChainAmounts
 from operate.resource import LocalResource
+from operate.serialization import BigInt
 from operate.wallet.master import MasterWalletManager
 
 
@@ -256,16 +257,16 @@ class Provider(ABC):
                 {
                     from_chain: {
                         from_address: {
-                            ZERO_ADDRESS: 0,
-                            from_token: 0,
+                            ZERO_ADDRESS: BigInt(0),
+                            from_token: BigInt(0),
                         }
                     }
                 }
             )
 
-        total_native = 0
-        total_gas_fees = 0
-        total_token = 0
+        total_native = BigInt(0)
+        total_gas_fees = BigInt(0)
+        total_token = BigInt(0)
 
         for tx_label, tx in txs:
             self.logger.debug(
@@ -273,8 +274,8 @@ class Provider(ABC):
             )
             update_tx_with_gas_pricing(tx, from_ledger_api)
             gas_key = "gasPrice" if "gasPrice" in tx else "maxFeePerGas"
-            gas_fees = tx.get(gas_key, 0) * tx["gas"]
-            tx_value = int(tx.get("value", 0))
+            gas_fees = BigInt(tx.get(gas_key, 0) * tx["gas"])
+            tx_value = BigInt(int(tx.get("value", 0)))
             total_gas_fees += gas_fees
             total_native += tx_value + gas_fees
 
@@ -290,7 +291,7 @@ class Provider(ABC):
                 "data", ""
             ).startswith(ERC20_APPROVE_SELECTOR):
                 try:
-                    amount = int(tx["data"][-64:], 16)
+                    amount = BigInt(tx["data"][-64:], 16)
                     total_token += amount
                 except Exception as e:
                     raise RuntimeError("Malformed ERC20 approve transaction.") from e

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/bridge/providers/relay_provider.py

@@ -101,6 +101,15 @@ RELAY_DEFAULT_GAS = {
         "swap": 400_000,
         "send": 1,
     },
+    Chain.ARBITRUM_ONE: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 400_000,
+        "send": 1,
+    },
 }
 
 

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/constants.py

@@ -21,6 +21,8 @@
 
 from pathlib import Path
 
+from operate.serialization import BigInt
+
 
 OPERATE = ".operate"
 OPERATE_HOME = Path.cwd() / OPERATE
@@ -54,8 +56,8 @@ AGENT_RUNNER_PREFIX = "agent_runner"
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 DEFAULT_TIMEOUT = 30
-MIN_AGENT_BOND = 1
-MIN_SECURITY_DEPOSIT = 1
+MIN_AGENT_BOND = BigInt(1)
+MIN_SECURITY_DEPOSIT = BigInt(1)
 
 ON_CHAIN_INTERACT_TIMEOUT = 120.0
 ON_CHAIN_INTERACT_RETRIES = 12

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/ledger/profiles.py

@@ -33,6 +33,7 @@ from operate.ledger import (
     get_default_ledger_api,
 )
 from operate.operate_types import Chain, ContractAddresses
+from operate.serialization import BigInt
 
 
 # TODO: Refactor, remove the usage of CONTRACTS and use CHAIN_PROFILES from Open Autonomy instead.
@@ -234,14 +235,14 @@ DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
 }
 
 DEFAULT_EOA_TOPUPS = {
-    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: 2_500_000_000_000_000},
-    Chain.BASE: {ZERO_ADDRESS: 2_500_000_000_000_000},
-    Chain.CELO: {ZERO_ADDRESS: 750_000_000_000_000_000},
-    Chain.ETHEREUM: {ZERO_ADDRESS: 10_000_000_000_000_000},
-    Chain.GNOSIS: {ZERO_ADDRESS: 750_000_000_000_000_000},
-    Chain.MODE: {ZERO_ADDRESS: 250_000_000_000_000},
-    Chain.OPTIMISM: {ZERO_ADDRESS: 2_500_000_000_000_000},
-    Chain.POLYGON: {ZERO_ADDRESS: 750_000_000_000_000_000},
+    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: BigInt(2_500_000_000_000_000)},
+    Chain.BASE: {ZERO_ADDRESS: BigInt(2_500_000_000_000_000)},
+    Chain.CELO: {ZERO_ADDRESS: BigInt(750_000_000_000_000_000)},
+    Chain.ETHEREUM: {ZERO_ADDRESS: BigInt(10_000_000_000_000_000)},
+    Chain.GNOSIS: {ZERO_ADDRESS: BigInt(750_000_000_000_000_000)},
+    Chain.MODE: {ZERO_ADDRESS: BigInt(250_000_000_000_000)},
+    Chain.OPTIMISM: {ZERO_ADDRESS: BigInt(2_500_000_000_000_000)},
+    Chain.POLYGON: {ZERO_ADDRESS: BigInt(750_000_000_000_000_000)},
 }
 
 DEFAULT_EOA_TOPUPS_WITHOUT_SAFE = {
@@ -250,14 +251,14 @@ DEFAULT_EOA_TOPUPS_WITHOUT_SAFE = {
 }
 
 DEFAULT_RECOVERY_TOPUPS = {
-    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: 625_000_000_000_000},
-    Chain.BASE: {ZERO_ADDRESS: 625_000_000_000_000},
-    Chain.CELO: {ZERO_ADDRESS: 187_500_000_000_000_000},
-    Chain.ETHEREUM: {ZERO_ADDRESS: 2_500_000_000_000_000},
-    Chain.GNOSIS: {ZERO_ADDRESS: 187_500_000_000_000_000},
-    Chain.MODE: {ZERO_ADDRESS: 62_500_000_000_000},
-    Chain.OPTIMISM: {ZERO_ADDRESS: 625_000_000_000_000},
-    Chain.POLYGON: {ZERO_ADDRESS: 187_500_000_000_000_000},
+    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: BigInt(625_000_000_000_000)},
+    Chain.BASE: {ZERO_ADDRESS: BigInt(625_000_000_000_000)},
+    Chain.CELO: {ZERO_ADDRESS: BigInt(187_500_000_000_000_000)},
+    Chain.ETHEREUM: {ZERO_ADDRESS: BigInt(2_500_000_000_000_000)},
+    Chain.GNOSIS: {ZERO_ADDRESS: BigInt(187_500_000_000_000_000)},
+    Chain.MODE: {ZERO_ADDRESS: BigInt(62_500_000_000_000)},
+    Chain.OPTIMISM: {ZERO_ADDRESS: BigInt(625_000_000_000_000)},
+    Chain.POLYGON: {ZERO_ADDRESS: BigInt(187_500_000_000_000_000)},
 }
 
 DEFAULT_EOA_THRESHOLD = 0.5

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/operate_types.py

@@ -36,6 +36,7 @@ from typing_extensions import TypedDict
 
 from operate.constants import FERNET_KEY_LENGTH, NO_STAKING_PROGRAM_ID
 from operate.resource import LocalResource
+from operate.serialization import BigInt, serialize
 
 
 LedgerType = LedgerTypeOA
@@ -178,8 +179,8 @@ class DeployedNodes(LocalResource):
 class OnChainFundRequirements(LocalResource):
     """On-chain fund requirements."""
 
-    agent: float
-    safe: float
+    agent: BigInt
+    safe: BigInt
 
 
 OnChainTokenRequirements = t.Dict[str, OnChainFundRequirements]
@@ -192,7 +193,7 @@ class OnChainUserParams(LocalResource):
     staking_program_id: str
     nft: str
     agent_id: int
-    cost_of_bond: int
+    cost_of_bond: BigInt
     fund_requirements: OnChainTokenRequirements
 
     @property
@@ -296,35 +297,54 @@ class Version:
         return self.patch < other.patch
 
 
-class ChainAmounts(dict[str, dict[str, dict[str, int]]]):
+class ChainAmounts(dict[str, dict[str, dict[str, BigInt]]]):
     """
     Class that represents chain amounts as a dictionary
 
     The standard format follows the convention {chain: {address: {token: amount}}}
     """
 
+    @property
+    def json(self) -> dict:
+        """Return JSON representation with amounts as strings."""
+        return serialize(self)
+
+    @staticmethod
+    def from_json(obj: dict) -> "ChainAmounts":
+        """Create ChainAmounts from JSON representation."""
+        result: dict[str, dict[str, dict[str, BigInt]]] = {}
+
+        for chain, addresses in obj.items():
+            for address, assets in addresses.items():
+                for asset, amount in assets.items():
+                    result.setdefault(chain, {}).setdefault(address, {})[asset] = (
+                        BigInt(amount)
+                    )
+
+        return ChainAmounts(result)
+
     @classmethod
     def shortfalls(
         cls, requirements: "ChainAmounts", balances: "ChainAmounts"
     ) -> "ChainAmounts":
         """Return the shortfalls between requirements and balances."""
-        result: dict[str, dict[str, dict[str, int]]] = {}
+        result: dict[str, dict[str, dict[str, BigInt]]] = {}
 
         for chain, addresses in requirements.items():
             for address, assets in addresses.items():
                 for asset, required_amount in assets.items():
                     available = balances.get(chain, {}).get(address, {}).get(asset, 0)
                     shortfall = max(required_amount - available, 0)
-                    result.setdefault(chain, {}).setdefault(address, {})[
-                        asset
-                    ] = shortfall
+                    result.setdefault(chain, {}).setdefault(address, {})[asset] = (
+                        BigInt(shortfall)
+                    )
 
         return cls(result)
 
     @classmethod
     def add(cls, *chainamounts: "ChainAmounts") -> "ChainAmounts":
         """Add multiple ChainAmounts"""
-        result: dict[str, dict[str, dict[str, int]]] = {}
+        result: dict[str, dict[str, dict[str, BigInt]]] = {}
 
         for ca in chainamounts:
             for chain, addresses in ca.items():
@@ -332,7 +352,9 @@ class ChainAmounts(dict[str, dict[str, dict[str, int]]]):
                 for address, assets in addresses.items():
                     result_assets = result_addresses.setdefault(address, {})
                     for asset, amount in assets.items():
-                        result_assets[asset] = result_assets.get(asset, 0) + amount
+                        result_assets[asset] = BigInt(
+                            result_assets.get(asset, 0) + amount
+                        )
 
         return cls(result)
 
@@ -346,7 +368,7 @@ class ChainAmounts(dict[str, dict[str, dict[str, int]]]):
         for _, addresses in output.items():
             for _, balances in addresses.items():
                 for asset, amount in balances.items():
-                    balances[asset] = int(amount * multiplier)
+                    balances[asset] = BigInt(int(amount * multiplier))
         return output
 
     def __sub__(self, other: "ChainAmounts") -> "ChainAmounts":
@@ -362,7 +384,7 @@ class ChainAmounts(dict[str, dict[str, dict[str, int]]]):
         for _, addresses in output.items():
             for _, balances in addresses.items():
                 for asset, amount in balances.items():
-                    balances[asset] = int(amount // divisor)
+                    balances[asset] = BigInt(int(amount // divisor))
         return output
 
     def __lt__(self, other: "ChainAmounts") -> bool:

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/quickstart/run_service.py

@@ -566,6 +566,9 @@ def get_service(manager: ServiceManager, template: ServiceTemplate) -> Service:
                 if env_var_name not in service.env_variables:
                     service.env_variables[env_var_name] = env_var_data
 
+                if env_var_data["provision_type"] == ServiceEnvProvisionType.FIXED:
+                    service.env_variables[env_var_name]["value"] = env_var_data["value"]
+
             service.update_user_params_from_template(service_template=template)
             service.store()
             break

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/resource.py

@@ -19,16 +19,14 @@
 
 """Local resource representation."""
 
-import enum
 import json
 import os
 import platform
 import shutil
-import types
 import typing as t
-from dataclasses import asdict, is_dataclass
 from pathlib import Path
 
+from operate.serialization import deserialize, serialize
 from operate.utils import safe_file_operation
 
 
@@ -38,63 +36,6 @@ from operate.utils import safe_file_operation
 N_BACKUPS = 5
 
 
-def serialize(obj: t.Any) -> t.Any:
-    """Serialize object."""
-    if is_dataclass(obj) and not isinstance(obj, type):
-        return serialize(asdict(obj))
-    if isinstance(obj, Path):
-        return str(obj)
-    if isinstance(obj, dict):
-        return {serialize(key): serialize(obj=value) for key, value in obj.items()}
-    if isinstance(obj, list):
-        return [serialize(obj=value) for value in obj]
-    if isinstance(obj, enum.Enum):
-        return obj.value
-    if isinstance(obj, bytes):
-        return obj.hex()
-    return obj
-
-
-def deserialize(obj: t.Any, otype: t.Any) -> t.Any:
-    """Desrialize a json object."""
-
-    origin = getattr(otype, "__origin__", None)
-
-    # Handle Union and Optional
-    if origin is t.Union or isinstance(otype, types.UnionType):
-        for arg in t.get_args(otype):
-            if arg is type(None):  # noqa: E721
-                continue
-            try:
-                return deserialize(obj, arg)
-            except Exception:  # pylint: disable=broad-except  # nosec
-                continue
-        return None
-
-    base = getattr(otype, "__class__")  # noqa: B009
-    if base.__name__ == "_GenericAlias":  # type: ignore
-        args = otype.__args__  # type: ignore
-        if len(args) == 1:
-            (atype,) = args
-            return [deserialize(arg, atype) for arg in obj]
-        if len(args) == 2:
-            (ktype, vtype) = args
-            return {
-                deserialize(key, ktype): deserialize(val, vtype)
-                for key, val in obj.items()
-            }
-        return obj
-    if base is enum.EnumMeta:
-        return otype(obj)
-    if otype is Path:
-        return Path(obj)
-    if is_dataclass(otype) and hasattr(otype, "from_json"):
-        return otype.from_json(obj)
-    if otype is bytes:
-        return bytes.fromhex(obj)
-    return obj
-
-
 class LocalResource:
     """Initialize local resource."""
 

olas_operate_middleware-0.14.0/operate/serialization.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2026 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+"""Serialization utilities."""
+
+import enum
+import types
+import typing as t
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+
+
+class BigInt(int):
+    """BigInt class for large integers that serialize as strings."""
+
+    def __iadd__(self, other: t.Union[int, str]) -> "BigInt":
+        """In-place addition."""
+        return BigInt(int(self) + int(other))
+
+    def __isub__(self, other: t.Union[int, str]) -> "BigInt":
+        """In-place subtraction."""
+        return BigInt(int(self) - int(other))
+
+    def __imul__(self, other: t.Union[int, str]) -> "BigInt":
+        """In-place multiplication."""
+        return BigInt(int(self) * int(other))
+
+    def __ifloordiv__(self, other: t.Union[int, str]) -> "BigInt":
+        """In-place floor division."""
+        return BigInt(int(self) // int(other))
+
+    def __itruediv__(self, other: t.Union[int, str]) -> "BigInt":
+        """In-place true division."""
+        return BigInt(int(self) / int(other))
+
+
+def serialize(obj: t.Any) -> t.Any:  # pylint: disable=too-many-return-statements
+    """Serialize object."""
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return serialize(asdict(obj))
+    if isinstance(obj, Path):
+        return str(obj)
+    if isinstance(obj, dict):
+        return {serialize(key): serialize(obj=value) for key, value in obj.items()}
+    if isinstance(obj, list):
+        return [serialize(obj=value) for value in obj]
+    if isinstance(obj, enum.Enum):
+        return obj.value
+    if isinstance(obj, bytes):
+        return obj.hex()
+    if hasattr(obj, "__class__") and obj.__class__.__name__ == "BigInt":
+        return str(obj)
+    return obj
+
+
+def deserialize(  # pylint: disable=too-many-return-statements
+    obj: t.Any, otype: t.Any
+) -> t.Any:
+    """Deserialize a json object."""
+
+    origin = getattr(otype, "__origin__", None)
+
+    # Handle Union and Optional
+    if origin is t.Union or isinstance(otype, types.UnionType):
+        for arg in t.get_args(otype):
+            if arg is type(None):  # noqa: E721
+                continue
+            try:
+                return deserialize(obj, arg)
+            except Exception:  # pylint: disable=broad-except  # nosec
+                continue
+        return None
+
+    base = getattr(otype, "__class__")  # noqa: B009
+    if base.__name__ == "_GenericAlias":  # type: ignore
+        args = otype.__args__  # type: ignore
+        if len(args) == 1:
+            (atype,) = args
+            return [deserialize(arg, atype) for arg in obj]
+        if len(args) == 2:
+            (ktype, vtype) = args
+            return {
+                deserialize(key, ktype): deserialize(val, vtype)
+                for key, val in obj.items()
+            }
+        return obj
+    if base is enum.EnumMeta:
+        return otype(obj)
+    if otype is Path:
+        return Path(obj)
+    if is_dataclass(otype) and hasattr(otype, "from_json"):
+        return otype.from_json(obj)
+    if otype is bytes:
+        return bytes.fromhex(obj)
+    if hasattr(otype, "__name__") and otype.__name__ == "BigInt":
+        return BigInt(obj)
+    return obj

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/services/funding_manager.py

@@ -58,6 +58,7 @@ from operate.ledger.profiles import (
     get_asset_name,
 )
 from operate.operate_types import Chain, ChainAmounts, LedgerType, OnChainState
+from operate.serialization import BigInt
 from operate.services.protocol import EthSafeTxBuilder, StakingManager, StakingState
 from operate.services.service import NON_EXISTENT_TOKEN, Service
 from operate.utils import concurrent_execute
@@ -253,23 +254,23 @@ class FundingManager:
             user_params = chain_config.chain_data.user_params
             number_of_agents = len(service.agent_addresses)
 
-            requirements: defaultdict = defaultdict(int)
+            requirements: defaultdict = defaultdict(BigInt)
 
             if (
                 not user_params.use_staking
                 or not user_params.staking_program_id
                 or user_params.staking_program_id == NO_STAKING_PROGRAM_ID
             ):
-                protocol_agent_bonds = (
+                protocol_agent_bonds = BigInt(
                     max(MIN_AGENT_BOND, user_params.cost_of_bond) * number_of_agents
                 )
                 protocol_security_deposit = max(
                     MIN_SECURITY_DEPOSIT, user_params.cost_of_bond
                 )
-                staking_agent_bonds = 0
-                staking_security_deposit = 0
+                staking_agent_bonds = BigInt(0)
+                staking_security_deposit = BigInt(0)
             else:
-                protocol_agent_bonds = MIN_AGENT_BOND * number_of_agents
+                protocol_agent_bonds = BigInt(MIN_AGENT_BOND * number_of_agents)
                 protocol_security_deposit = MIN_SECURITY_DEPOSIT
 
                 staking_manager = StakingManager(chain=Chain(chain))
@@ -279,10 +280,10 @@ class FundingManager:
                     ),
                 )
 
-                staking_agent_bonds = (
+                staking_agent_bonds = BigInt(
                     staking_params["min_staking_deposit"] * number_of_agents
                 )
-                staking_security_deposit = staking_params["min_staking_deposit"]
+                staking_security_deposit = BigInt(staking_params["min_staking_deposit"])
                 staking_token = staking_params["staking_token"]
                 requirements[staking_token] += staking_agent_bonds
                 requirements[staking_token] += staking_security_deposit
@@ -290,7 +291,7 @@ class FundingManager:
                 for token, amount in staking_params[
                     "additional_staking_tokens"
                 ].items():
-                    requirements[token] = amount
+                    requirements[token] = BigInt(amount)
 
             requirements[ZERO_ADDRESS] += protocol_agent_bonds
             requirements[ZERO_ADDRESS] += protocol_security_deposit
@@ -316,7 +317,7 @@ class FundingManager:
         protocol_bonded_assets = ChainAmounts()
 
         for chain, chain_config in service.chain_configs.items():
-            bonded_assets: defaultdict = defaultdict(int)
+            bonded_assets: defaultdict = defaultdict(BigInt)
             ledger_config = chain_config.ledger_config
             user_params = chain_config.chain_data.user_params
 
@@ -366,7 +367,8 @@ class FundingManager:
             )
 
             # Determine bonded native amount
-            security_deposit = service_info[0]
+            operator_balance = BigInt(operator_balance)
+            security_deposit = BigInt(service_info[0])
             service_state = service_info[6]
             agent_ids = service_info[7]
 
@@ -449,25 +451,25 @@ class FundingManager:
                 ),
             )
 
-            agent_bonds = 0
+            agent_bonds = BigInt(0)
             for agent_instances, agent_bond in zip(
                 agent_instances_and_bonds[: len(agent_ids)],
                 agent_instances_and_bonds[len(agent_ids) :],
             ):
                 num_agent_instances = agent_instances[0]
-                agent_bonds += num_agent_instances * agent_bond
+                agent_bonds += BigInt(num_agent_instances * agent_bond)
 
             if service_state == OnChainState.TERMINATED_BONDED:
                 num_agent_instances = service_info[5]
-                agent_bonds += num_agent_instances * token_bond
+                agent_bonds += BigInt(num_agent_instances * token_bond)
 
-            security_deposit = 0
+            security_deposit = BigInt(0)
             if (
                 OnChainState.ACTIVE_REGISTRATION
                 <= service_state
                 < OnChainState.TERMINATED_BONDED
             ):
-                security_deposit = security_deposits[1]
+                security_deposit = BigInt(security_deposits[1])
 
             bonded_assets[staking_params["staking_token"]] += agent_bonds
             bonded_assets[staking_params["staking_token"]] += security_deposit
@@ -476,7 +478,7 @@ class FundingManager:
                 for token, amount in staking_params[
                     "additional_staking_tokens"
                 ].items():
-                    bonded_assets[token] += amount
+                    bonded_assets[token] += BigInt(amount)
 
             protocol_bonded_assets[chain] = {master_safe: dict(bonded_assets)}
 
@@ -871,14 +873,14 @@ class FundingManager:
             allow_start_agent = False
 
         return {
-            "balances": balances,
-            "bonded_assets": protocol_bonded_assets,
-            "total_requirements": total_requirements,
-            "refill_requirements": refill_requirements,
-            "protocol_asset_requirements": protocol_asset_requirements,
+            "balances": balances.json,
+            "bonded_assets": protocol_bonded_assets.json,
+            "total_requirements": total_requirements.json,
+            "refill_requirements": refill_requirements.json,
+            "protocol_asset_requirements": protocol_asset_requirements.json,
             "is_refill_required": is_refill_required,
             "allow_start_agent": allow_start_agent,
-            "agent_funding_requests": funding_requests,
+            "agent_funding_requests": funding_requests.json,
             "agent_funding_requests_cooldown": funding_requests_cooldown,
             "agent_funding_in_progress": funding_in_progress,
         }

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/services/service.py

@@ -96,6 +96,7 @@ from operate.operate_types import (
     ServiceTemplate,
 )
 from operate.resource import LocalResource
+from operate.serialization import BigInt
 from operate.services.deployment_runner import run_host_deployment, stop_host_deployment
 from operate.services.utils import tendermint
 from operate.utils import unrecoverable_delete
@@ -1258,7 +1259,7 @@ class Service(LocalResource):
                 funding_requests[chain_str].setdefault(address, {})
                 for asset, amounts in assets.items():
                     try:
-                        funding_requests[chain_str][address][asset] = int(
+                        funding_requests[chain_str][address][asset] = BigInt(
                             amounts["deficit"]
                         )
                     except (ValueError, TypeError):

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/settings.py

@@ -25,6 +25,7 @@ from operate.constants import SETTINGS_JSON
 from operate.ledger.profiles import DEFAULT_EOA_TOPUPS
 from operate.operate_types import ChainAmounts
 from operate.resource import LocalResource
+from operate.serialization import BigInt
 
 
 SETTINGS_JSON_VERSION = 1
@@ -40,7 +41,7 @@ class Settings(LocalResource):
     _file = SETTINGS_JSON
 
     version: int
-    eoa_topups: Dict[str, Dict[str, int]]
+    eoa_topups: Dict[str, Dict[str, BigInt]]
 
     def __init__(self, path: Optional[Path] = None, **kwargs: Any) -> None:
         """Initialize settings."""
@@ -60,11 +61,13 @@ class Settings(LocalResource):
 
     def get_eoa_topups(self, with_safe: bool = False) -> ChainAmounts:
         """Get the EOA topups."""
-        return (
+        return ChainAmounts(
             self.eoa_topups
             if with_safe
             else {
-                chain: {asset: amount * 2 for asset, amount in asset_amount.items()}
+                chain: {
+                    asset: BigInt(amount * 2) for asset, amount in asset_amount.items()
+                }
                 for chain, asset_amount in self.eoa_topups.items()
             }
         )

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/utils/__init__.py

@@ -34,6 +34,7 @@ from pathlib import Path
 from threading import Lock
 
 from operate.constants import DEFAULT_TIMEOUT
+from operate.serialization import BigInt
 
 
 logger = logging.getLogger(__name__)
@@ -118,7 +119,7 @@ def subtract_dicts(
                 va if isinstance(va, dict) else {}, vb if isinstance(vb, dict) else {}
             )
         else:
-            result[key] = max((va or 0) - (vb or 0), 0)  # type: ignore
+            result[key] = BigInt(max((va or 0) - (vb or 0), 0))  # type: ignore
     return result
 
 

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/utils/gnosis.py

@@ -41,6 +41,7 @@ from operate.constants import (
 )
 from operate.ledger import get_default_ledger_api
 from operate.operate_types import Chain
+from operate.serialization import BigInt
 
 
 logger = setup_logger(name="operate.utils.gnosis")
@@ -572,7 +573,7 @@ def get_asset_balance(
     asset_address: str,
     address: str,
     raise_on_invalid_address: bool = True,
-) -> int:
+) -> BigInt:
     """
     Get the balance of a native asset or ERC20 token.
 
@@ -581,12 +582,12 @@ def get_asset_balance(
     if not Web3.is_address(address):
         if raise_on_invalid_address:
             raise ValueError(f"Invalid address: {address}")
-        return 0
+        return BigInt(0)
 
     try:
         if asset_address == ZERO_ADDRESS:
-            return ledger_api.get_balance(address, raise_on_try=True)
-        return (
+            return BigInt(ledger_api.get_balance(address, raise_on_try=True))
+        return BigInt(
             registry_contracts.erc20.get_instance(
                 ledger_api=ledger_api,
                 contract_address=asset_address,
@@ -605,13 +606,13 @@ def get_assets_balances(
     asset_addresses: t.Set[str],
     addresses: t.Set[str],
     raise_on_invalid_address: bool = True,
-) -> t.Dict[str, t.Dict[str, int]]:
+) -> t.Dict[str, t.Dict[str, BigInt]]:
     """
     Get the balances of a list of native assets or ERC20 tokens.
 
     If asset address is a zero address, return the native balance.
     """
-    output: t.Dict[str, t.Dict[str, int]] = {}
+    output: t.Dict[str, t.Dict[str, BigInt]] = {}
 
     for asset, address in itertools.product(asset_addresses, addresses):
         output.setdefault(address, {})[asset] = get_asset_balance(

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/wallet/master.py

@@ -48,6 +48,7 @@ from operate.ledger import (
 from operate.ledger.profiles import DUST, ERC20_TOKENS, format_asset_amount
 from operate.operate_types import Chain, EncryptedData, LedgerType
 from operate.resource import LocalResource
+from operate.serialization import BigInt
 from operate.utils import create_backup
 from operate.utils.gnosis import add_owner
 from operate.utils.gnosis import create_safe as create_gnosis_safe
@@ -211,7 +212,7 @@ class MasterWallet(LocalResource):
 
     def get_balance(
         self, chain: Chain, asset: str = ZERO_ADDRESS, from_safe: bool = True
-    ) -> int:
+    ) -> BigInt:
         """Get wallet balance on a given chain."""
         if from_safe:
             if chain not in self.safes:
@@ -770,7 +771,7 @@ class EthereumMasterWallet(MasterWallet):
         rpc = None
         wallet_json = self.json
 
-        balances: t.Dict[str, t.Dict[str, t.Dict[str, int]]] = {}
+        balances: t.Dict[str, t.Dict[str, t.Dict[str, BigInt]]] = {}
         owner_sets = set()
         for chain, safe in self.safes.items():
             chain_str = chain.value
@@ -784,11 +785,11 @@ class EthereumMasterWallet(MasterWallet):
 
             assets = [token[chain] for token in ERC20_TOKENS.values()] + [ZERO_ADDRESS]
             for asset in assets:
-                balances[chain_str][self.address][asset] = self.get_balance(
-                    chain=chain, asset=asset, from_safe=False
+                balances[chain_str][self.address][asset] = str(
+                    self.get_balance(chain=chain, asset=asset, from_safe=False)
                 )
-                balances[chain_str][safe][asset] = self.get_balance(
-                    chain=chain, asset=asset, from_safe=True
+                balances[chain_str][safe][asset] = str(
+                    self.get_balance(chain=chain, asset=asset, from_safe=True)
                 )
             wallet_json["safes"][chain_str] = {
                 safe: {

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/operate/wallet/wallet_recovery_manager.py

@@ -40,6 +40,7 @@ from operate.ledger import get_default_ledger_api
 from operate.ledger.profiles import DEFAULT_RECOVERY_TOPUPS
 from operate.operate_types import ChainAmounts
 from operate.resource import LocalResource
+from operate.serialization import BigInt
 from operate.services.manage import ServiceManager
 from operate.utils.gnosis import get_asset_balance, get_owners
 from operate.wallet.master import MasterWalletManager
@@ -330,7 +331,7 @@ class WalletRecoveryManager:
                         raise_on_invalid_address=False,
                     )
                     requirements[chain_str].setdefault(backup_owner, {}).setdefault(
-                        ZERO_ADDRESS, 0
+                        ZERO_ADDRESS, BigInt(0)
                     )
                     if new_wallet.address not in owners:
                         requirements[chain_str][backup_owner][
@@ -351,9 +352,9 @@ class WalletRecoveryManager:
         )
 
         return {
-            "balances": balances,
-            "total_requirements": requirements,
-            "refill_requirements": refill_requirements,
+            "balances": balances.json,
+            "total_requirements": requirements.json,
+            "refill_requirements": refill_requirements.json,
             "is_refill_required": is_refill_required,
             "pending_backup_owner_swaps": pending_backup_owner_swaps,
         }

{olas_operate_middleware-0.13.10 → olas_operate_middleware-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "olas-operate-middleware"
-version = "0.13.10"
+version = "0.14.0"
 description = ""
 authors = ["David Vilela <dvilelaf@gmail.com>", "Viraj Patel <vptl185@gmail.com>"]
 readme = "README.md"