olas-operate-middleware 0.13.11__py3-none-any.whl → 0.14.1__py3-none-any.whl

{olas_operate_middleware-0.13.11.dist-info → olas_operate_middleware-0.14.1.dist-info}/METADATA

@@ -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.dist-info → olas_operate_middleware-0.14.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 operate/__init__.py,sha256=_pgD-4F4Gc9xSPxbJxiQkw0m5rSHhLjxN7mDRNm0iCE,2652
 operate/account/__init__.py,sha256=suJ_vBMO7hLCvLYe3MVDtLXTNDd6P03og7bvUN7fZsE,804
 operate/account/user.py,sha256=y7DqqDpqgHjbVmnfL_cN0Me_JWl3Dh6GSVt2-9FdRVw,3044
-operate/bridge/bridge_manager.py,sha256=K5DMYGqgX0xw3pxzZXrwnCQ8ZKpy-HVsfNRM185xb5g,17445
+operate/bridge/bridge_manager.py,sha256=X3TQDevI5WRsn9PRbGUbaNaZujJWKutYpPZeH2QG9qM,17460
 operate/bridge/providers/lifi_provider.py,sha256=UzAeEnX9FGpnCYYml5lcICeEZeHHqNRCHkGZ-npgteo,14208
 operate/bridge/providers/native_bridge_provider.py,sha256=vAx0MtVPIAxIdQ5OKSUDhnGurYVkC8tKVJRFK9NkIdk,25088
-operate/bridge/providers/provider.py,sha256=Ra-HBzcq2fSBSZWu9Qv1WsuBiMtU6IXYL5lc6D6cvZM,16881
-operate/bridge/providers/relay_provider.py,sha256=4D2U8jrugh2DJZeSoxLCTVSZe8xMEwdCimqFDtfwWwc,17422
+operate/bridge/providers/provider.py,sha256=E5d3yFe7WYZd_IbQIgDVf6F5MMJ8vMOm1o-qeqJJSCk,16981
+operate/bridge/providers/relay_provider.py,sha256=QU9H9mCAUgQx-qMKXkCGfFNimi1WGoxmKO30F2K9erw,17628
 operate/cli.py,sha256=2Rg4pIRZMMK7U2xgMuX3CEueOXi280cUzk-avZ3E1aw,69786
-operate/constants.py,sha256=3awbelHUI9y3ZvTmpJjEu39qRq2ZSSqhPaWTeJ9CwXU,3875
+operate/constants.py,sha256=oBxZEnhETCd96GWz2QDUZd-0-ofV-1deKNvFPl4-mmM,3933
 operate/data/README.md,sha256=jGPyZTvg2LCGdllvmYxmFMkkkiXb6YWatbqIkcX3kv4,879
 operate/data/__init__.py,sha256=ttC51Yqk9c4ehpIgs1Qbe7aJvzkrbbdZ1ClaCxJYByE,864
 operate/data/contracts/__init__.py,sha256=_th54_WvL0ibGy-b6St0Ne9DX-fyjsh-tNOKDn-cWrg,809
@@ -59,43 +59,44 @@ operate/data/contracts/uniswap_v2_erc20/tests/__init__.py,sha256=3Arw8dsCsJz6hVO
 operate/data/contracts/uniswap_v2_erc20/tests/test_contract.py,sha256=z4GfybA_oZUA6-sl61qaJ78rXdbcW_rk4APzgMzQD38,13456
 operate/keys.py,sha256=qfT3-ZS1R2jG_t7BdqUdgrAYqHnj6dNrtK5c0-_AODU,6179
 operate/ledger/__init__.py,sha256=c41SqGLSpLBvG_q1cPyDh1aunByopsIIC5Mfk1vdmQE,6207
-operate/ledger/profiles.py,sha256=D-2K99UJjqTwPW8fWICRRCIIXdSZC0uocbtb-e40YPU,14984
+operate/ledger/profiles.py,sha256=ElxkFcZ9gt9Cetn6nWC0v63Ca0Eo8YTt9_amnI1v6RQ,15153
 operate/migration.py,sha256=hdZlhhdkoPPzkOD0CFyNYAp-eqUrVu_PJnw8_PoxpWk,21015
 operate/operate_http/__init__.py,sha256=MTS1tMZ5qnA_WzaoeLxlK9IJToMGIpkNr7_vyBeAqZ8,4680
 operate/operate_http/exceptions.py,sha256=4UFzrn-GyDD71RhkaOyFPBynL6TrrtP3eywaaU3o4fc,1339
-operate/operate_types.py,sha256=TCmbLfJIbo-OyvpMN9PBcfYj94e00zttVPcQ0GnwyWs,13038
+operate/operate_types.py,sha256=tsGL1vC0dSZidseG1A_2oAPEpxEHXM7YhtGVcuifBDw,13855
 operate/pearl.py,sha256=yrTpSXLu_ML3qT-uNxq3kScOyo31JyxBujiSMfMUbcg,1690
 operate/quickstart/analyse_logs.py,sha256=cAeAL2iUy0Po8Eor70tq54-Ibg-Dn8rkuaS167yjE_I,4198
 operate/quickstart/claim_staking_rewards.py,sha256=K7X1Yq0mxe3qWmFLb1Xu9-Jghhml95lS_LpM_BXii0o,3533
 operate/quickstart/reset_configs.py,sha256=DVPM4mh6Djunwq16hf8lD9-nGkkm7wVtwr2JUXr1if8,3380
 operate/quickstart/reset_password.py,sha256=jEBk2ROR1q8PkTIHlqum7E8PRQtXHwrauiy0_bik3RQ,2394
 operate/quickstart/reset_staking.py,sha256=SB5LZq9EctG4SYn2M6oPZ7R7ARHSFLRGzAqfKkpRcy0,5111
-operate/quickstart/run_service.py,sha256=myncdvwHD9DDgjj6fBVC2Ju4SplfBUZnPyXu0Z2gNYg,30279
+operate/quickstart/run_service.py,sha256=tt4PYeZJ2MtYeG59vohOdMbOiCYGGUmGnjeZwYl0shQ,30383
 operate/quickstart/stop_service.py,sha256=a3-1vVyZma2UtFUPKMvVrOso1Iwpz5Rzpus9VAI4qOc,2169
 operate/quickstart/terminate_on_chain_service.py,sha256=5ENU8_mkj06i80lKUX-v1QbLU0YzKeOZDUL1e_jzySE,2914
 operate/quickstart/utils.py,sha256=i1juhJCPkzB7ZKgSk5tNiRmYxGcx8MG-dTjVyC5sKys,9287
-operate/resource.py,sha256=LlHJWw66RLIA9TV3HIQ6p7zZSIqoUvn3ntaVs4eRs-g,5803
+operate/resource.py,sha256=0KeQkWojN737er4USSJMVC9tQEmWtXWdXj8xPEfaHqI,3954
+operate/serialization.py,sha256=mf2uJCj1WULaTIJSYQ-XuaW3bdwc0vn-cxk2q0IJQf4,3885
 operate/services/__init__.py,sha256=isrThS-Ccu5Sc15JZgkN4uTAVaSg-NwUUSDeTyJEqLk,855
 operate/services/agent_runner.py,sha256=JGjyrzA5hX4Nuh79h81-dl2hdt74ZkC63t7UsGXY6Rw,7500
 operate/services/deployment_runner.py,sha256=7A94QpZu100BwIk1Q9Cr0SVK5Sj7nTWx2GRCwr0gvaM,30772
-operate/services/funding_manager.py,sha256=4jcu3KHQOKaaX5AYJsKb-F6GnsSy5fiqC_mWpe7wKVk,41431
+operate/services/funding_manager.py,sha256=q-mO6kQWthCLI5uW8qbrMQw_6i--zd1rJ3SG4tbw6FM,41672
 operate/services/health_checker.py,sha256=dARikrgzU1jEuK4NUqlZ7N0DQq4Ah1ZiRKHmrlh8v-A,11472
 operate/services/manage.py,sha256=9dTjXhBq6tgcFWfhU61JQL67L2h3_b_7p8OICimWWB4,113292
 operate/services/protocol.py,sha256=4wAMHoELkqJJlETsMJa-XT8xVA0jfueiaKMn7X4SUKo,71898
-operate/services/service.py,sha256=WK1RSe83OceETmzpzR22vpWdx1qMkF2J6RSf4P9GTyk,45363
+operate/services/service.py,sha256=YOU0rlPe5PjDnFRlAcThYLvr5MrPOftBDKZHMRNzZ78,46647
 operate/services/utils/__init__.py,sha256=TvioaZ1mfTRUSCtrQoLNAp4WMVXyqEJqFJM4PxSQCRU,24
 operate/services/utils/mech.py,sha256=98gNw8pMNvv_O34V1blr7JUwenqxFeeyFuXLuSYv10w,3864
 operate/services/utils/tendermint.py,sha256=M4zjF97SOJomhmj97bWKIphnia30lbDie65fs_vy_q8,25686
-operate/settings.py,sha256=0J2E69-Oplo-Ijy-7rzYHc2Q9Xvct-EUMiEdmKKaYOQ,2353
-operate/utils/__init__.py,sha256=LD5xScW5ZW9pJeBg1h_9ydj0epPcRXbP0v7OVV85Cl8,8560
-operate/utils/gnosis.py,sha256=mw-K-_xmRnY7QYl6Bzrh-jP7_JwHyiXhvwX6pCMSgt8,18056
+operate/settings.py,sha256=is8NE-ls0PyJDsPOevwFtFHAIVtkuX-PIDTl-bMK6Qo,2455
+operate/utils/__init__.py,sha256=bp_3fka3K0iSJEEe4cNlHTCb6Q5AAAu4RI4fhiVw6cM,8609
+operate/utils/gnosis.py,sha256=1PrEnwkVF9lEFsFJlQXk5yXFsARGnIMPhJCrN-pRrxs,18128
 operate/utils/single_instance.py,sha256=1qVibsLoK2m45ip38kRC6IMghaza_kD14D0wAbevcYk,9090
 operate/utils/ssl.py,sha256=O5DrDoZD4T4qQuHP8GLwWUVxQ-1qXeefGp6uDJiF2lM,4308
 operate/wallet/__init__.py,sha256=NGiozD3XhvkBi7_FaOWQ8x1thZPK4uGpokJaeDY_o2w,813
-operate/wallet/master.py,sha256=5UvfEDFjgHNOHC25ZhZeewte1kXr69YPs5ue1NYSe5Q,33751
-operate/wallet/wallet_recovery_manager.py,sha256=Dn0QmOYmmNj4p1X1TVQOrua3fysR3XJ99m6Z3H7tJQI,19792
-olas_operate_middleware-0.13.11.dist-info/METADATA,sha256=KdXRjShg1XPVGB8ZTQFOadXprdZjviExImHafXLxl4U,1493
-olas_operate_middleware-0.13.11.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-olas_operate_middleware-0.13.11.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
-olas_operate_middleware-0.13.11.dist-info/licenses/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
-olas_operate_middleware-0.13.11.dist-info/RECORD,,
+operate/wallet/master.py,sha256=019VvWsMfzAV3fUienhcYVLB12BcSVvub3weAeMOlSA,33808
+operate/wallet/wallet_recovery_manager.py,sha256=kZIKBCIVb-ufntUoCE0IqAJ-Q2YUIl7955UYY6sp8Os,19856
+olas_operate_middleware-0.14.1.dist-info/METADATA,sha256=f-5TTJaF2_pDz2a0j7nRdvqdokleT2m2-gJ94jf2YI4,1492
+olas_operate_middleware-0.14.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+olas_operate_middleware-0.14.1.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
+olas_operate_middleware-0.14.1.dist-info/licenses/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
+olas_operate_middleware-0.14.1.dist-info/RECORD,,

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,
             }

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

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,
+    },
 }
 
 

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

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

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:

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,

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."""
 

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

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,
         }

operate/services/service.py

@@ -77,6 +77,7 @@ from operate.constants import (
 )
 from operate.keys import KeysManager
 from operate.ledger import get_default_ledger_api, get_default_rpc
+from operate.ledger.profiles import WRAPPED_NATIVE_ASSET
 from operate.operate_http.exceptions import NotAllowed
 from operate.operate_types import (
     AgentRelease,
@@ -96,6 +97,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
@@ -1199,10 +1201,13 @@ class Service(LocalResource):
 
         return amounts
 
-    def get_balances(self) -> ChainAmounts:
-        """Get balances of the agent addresses and service safe."""
+    def get_balances(self, unify_wrapped_native_tokens: bool = True) -> ChainAmounts:
+        """Get balances of the agent addresses and service safe.
+
+        :param unify_wrapped_native_tokens: Whether to consider wrapped native tokens as native tokens.
+        """
         initial_funding_amounts = self.get_initial_funding_amounts()
-        return ChainAmounts(
+        absolute_balances = ChainAmounts(
             {
                 chain_str: {
                     address: {
@@ -1221,6 +1226,27 @@ class Service(LocalResource):
                 for chain_str, addresses in initial_funding_amounts.items()
             }
         )
+        if unify_wrapped_native_tokens:
+            for chain_str, addresses in absolute_balances.items():
+                chain = Chain.from_string(chain_str)
+                wrapped_asset = WRAPPED_NATIVE_ASSET[chain]
+                for address, assets in addresses.items():
+                    if ZERO_ADDRESS in assets or wrapped_asset in assets:
+                        if ZERO_ADDRESS not in assets:
+                            assets[ZERO_ADDRESS] = 0
+
+                    if wrapped_asset in assets:
+                        assets[ZERO_ADDRESS] += assets[wrapped_asset]
+                        del assets[wrapped_asset]
+                    else:
+                        assets[ZERO_ADDRESS] += get_asset_balance(
+                            ledger_api=get_default_ledger_api(chain),
+                            asset_address=wrapped_asset,
+                            address=address,
+                            raise_on_invalid_address=False,
+                        )
+
+        return absolute_balances
 
     def get_funding_requests(self) -> ChainAmounts:
         """Get funding amounts requested by the agent."""
@@ -1258,7 +1284,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):

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()
             }
         )

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
 
 

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(

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: {

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,
         }