olas-operate-middleware 0.13.11__tar.gz → 0.14.1__tar.gz

{olas_operate_middleware-0.13.11 → olas_operate_middleware-0.14.1}/PKG-INFO

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

{olas_operate_middleware-0.13.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/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.11 → olas_operate_middleware-0.14.1}/operate/quickstart/run_service.py

@@ -46,6 +46,7 @@ from operate.ledger import DEFAULT_RPCS
 from operate.ledger.profiles import STAKING, get_staking_contract
 from operate.operate_types import (
     Chain,
+    ChainAmounts,
     LedgerType,
     ServiceEnvProvisionType,
     ServiceTemplate,
@@ -649,7 +650,9 @@ def _ask_funds_from_requirements(
     )
 
     if not requirements["is_refill_required"] and requirements["allow_start_agent"]:
-        for chain_name, balances in requirements["balances"].items():
+        for chain_name, balances in ChainAmounts.from_json(
+            requirements["balances"]
+        ).items():
             ledger_api = wallet.ledger_api(
                 chain=Chain(chain_name),
                 rpc=service.chain_configs[chain_name].ledger_config.rpc,
@@ -662,17 +665,19 @@ def _ask_funds_from_requirements(
 
         return True
 
-    for chain_name, chain_requirements in requirements["refill_requirements"].items():
+    for chain_name, chain_requirements in ChainAmounts.from_json(
+        requirements["refill_requirements"]
+    ).items():
         chain = Chain(chain_name)
         ledger_api = wallet.ledger_api(
             chain=chain,
             rpc=service.chain_configs[chain_name].ledger_config.rpc,
         )
-        for wallet_address, requirements in chain_requirements.items():
+        for wallet_address, _requirements in chain_requirements.items():
             if wallet_address in ("master_safe", "service_safe"):
                 continue  # we can't ask funds in placeholder addresses
 
-            for asset_address, requirement in requirements.items():
+            for asset_address, requirement in _requirements.items():
                 ask_funds_in_address(
                     ledger_api=ledger_api,
                     chain=chain_name,

{olas_operate_middleware-0.13.11 → olas_operate_middleware-0.14.1}/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.1/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.11 → olas_operate_middleware-0.14.1}/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,
         }