olas-operate-middleware 0.1.0rc59__py3-none-any.whl → 0.13.2__py3-none-any.whl

operate/ledger/__init__.py

@@ -21,79 +21,182 @@
 
 import os
 import typing as t
+from copy import deepcopy
+from math import ceil
+
+from aea.crypto.base import LedgerApi
+from aea.crypto.registries import make_ledger_api
+from aea_ledger_ethereum import DEFAULT_GAS_PRICE_STRATEGIES, EIP1559, GWEI, to_wei
+from web3.middleware import geth_poa_middleware
+
+from operate.operate_types import Chain
+
+
+CHAINS = [
+    Chain.ARBITRUM_ONE,
+    Chain.BASE,
+    Chain.CELO,
+    Chain.ETHEREUM,
+    Chain.GNOSIS,
+    Chain.MODE,
+    Chain.OPTIMISM,
+    Chain.POLYGON,
+    Chain.SOLANA,
+]
+
+ARBITRUM_ONE_RPC = os.environ.get("ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc")
+BASE_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
+CELO_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
+ETHEREUM_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
+GNOSIS_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
+MODE_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network")
+OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+POLYGON_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
+SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
-from operate.ledger.base import LedgerHelper
-from operate.ledger.ethereum import Ethereum
-from operate.ledger.solana import Solana
-from operate.types import ChainType, LedgerType
-
-
-ETHEREUM_PUBLIC_RPC = os.environ.get("DEV_RPC", "https://ethereum.publicnode.com")
-GNOSIS_PUBLIC_RPC = os.environ.get("DEV_RPC", "https://gnosis-rpc.publicnode.com")
-GOERLI_PUBLIC_RPC = os.environ.get("DEV_RPC", "https://ethereum-goerli.publicnode.com")
-SOLANA_PUBLIC_RPC = os.environ.get("DEV_RPC", "https://api.mainnet-beta.solana.com")
-
-ETHEREUM_RPC = os.environ.get("DEV_RPC", "https://ethereum.publicnode.com")
-GNOSIS_RPC = os.environ.get("DEV_RPC", "https://rpc-gate.autonolas.tech/gnosis-rpc/")
-GOERLI_RPC = os.environ.get("DEV_RPC", "https://ethereum-goerli.publicnode.com")
-SOLANA_RPC = os.environ.get("DEV_RPC", "https://api.mainnet-beta.solana.com")
-
-PUBLIC_RPCS = {
-    ChainType.ETHEREUM: ETHEREUM_PUBLIC_RPC,
-    ChainType.GNOSIS: GNOSIS_PUBLIC_RPC,
-    ChainType.GOERLI: GOERLI_PUBLIC_RPC,
-    ChainType.SOLANA: SOLANA_PUBLIC_RPC,
-}
 
 DEFAULT_RPCS = {
-    ChainType.ETHEREUM: ETHEREUM_RPC,
-    ChainType.GNOSIS: GNOSIS_RPC,
-    ChainType.GOERLI: GOERLI_RPC,
-    ChainType.SOLANA: SOLANA_RPC,
+    Chain.ARBITRUM_ONE: ARBITRUM_ONE_RPC,
+    Chain.BASE: BASE_RPC,
+    Chain.CELO: CELO_RPC,
+    Chain.ETHEREUM: ETHEREUM_RPC,
+    Chain.GNOSIS: GNOSIS_RPC,
+    Chain.MODE: MODE_RPC,
+    Chain.OPTIMISM: OPTIMISM_RPC,
+    Chain.POLYGON: POLYGON_RPC,
+    Chain.SOLANA: SOLANA_RPC,
 }
 
-CHAIN_HELPERS: t.Dict[ChainType, t.Type[LedgerHelper]] = {
-    ChainType.ETHEREUM: Ethereum,
-    ChainType.GNOSIS: Ethereum,
-    ChainType.GOERLI: Ethereum,
-    ChainType.SOLANA: Solana,
+# Base currency for each chain
+CURRENCY_DENOMS = {
+    Chain.ARBITRUM_ONE: "ETH",
+    Chain.BASE: "ETH",
+    Chain.CELO: "CELO",
+    Chain.ETHEREUM: "ETH",
+    Chain.GNOSIS: "xDAI",
+    Chain.MODE: "ETH",
+    Chain.OPTIMISM: "ETH",
+    Chain.POLYGON: "POL",
+    Chain.SOLANA: "SOL",
 }
 
-LEDGER_HELPERS: t.Dict[LedgerType, t.Type[LedgerHelper]] = {
-    LedgerType.ETHEREUM: Ethereum,
-    LedgerType.SOLANA: Solana,
+# Smallest denomination for each chain
+CURRENCY_SMALLEST_UNITS = {
+    Chain.ARBITRUM_ONE: "Wei",
+    Chain.BASE: "Wei",
+    Chain.CELO: "Wei",
+    Chain.ETHEREUM: "Wei",
+    Chain.GNOSIS: "Wei",
+    Chain.MODE: "Wei",
+    Chain.OPTIMISM: "Wei",
+    Chain.POLYGON: "Wei",
+    Chain.SOLANA: "Lamport",
 }
 
-CURRENCY_DENOMS = {
-    ChainType.ETHEREUM: "Wei",
-    ChainType.GNOSIS: "xDai",
-    ChainType.GOERLI: "GWei",
-    ChainType.SOLANA: "Lamp",
-}
+NATIVE_CURRENCY_DECIMALS = 18
 
 
-def get_default_rpc(chain: ChainType) -> str:
+def get_default_rpc(chain: Chain) -> str:
     """Get default RPC chain type."""
-    return DEFAULT_RPCS.get(chain, ETHEREUM_RPC)
+    return DEFAULT_RPCS[chain]
 
 
-def get_ledger_type_from_chain_type(chain: ChainType) -> LedgerType:
-    """Get LedgerType from ChainType."""
-    if chain in (ChainType.ETHEREUM, ChainType.GOERLI, ChainType.GNOSIS):
-        return LedgerType.ETHEREUM
-    return LedgerType.SOLANA
+def get_currency_denom(chain: Chain) -> str:
+    """Get currency denom by chain type."""
+    return CURRENCY_DENOMS.get(chain, "NATIVE")
 
 
-def get_ledger_helper_by_chain(rpc: str, chain: ChainType) -> LedgerHelper:
-    """Get ledger helper by chain type."""
-    return CHAIN_HELPERS.get(chain, Ethereum)(rpc=rpc)
+def get_currency_smallest_unit(chain: Chain) -> str:
+    """Get currency denom by chain type."""
+    return CURRENCY_SMALLEST_UNITS.get(chain, "Wei")
 
 
-def get_ledger_helper_by_ledger(rpc: str, ledger: LedgerHelper) -> LedgerHelper:
-    """Get ledger helper by ledger type."""
-    return LEDGER_HELPERS.get(ledger, Ethereum)(rpc=rpc)  # type: ignore
+DEFAULT_LEDGER_APIS: t.Dict[Chain, LedgerApi] = {}
 
 
-def get_currency_denom(chain: ChainType) -> str:
-    """Get currency denom by chain type."""
-    return CURRENCY_DENOMS.get(chain, "Wei")
+def make_chain_ledger_api(
+    chain: Chain,
+    rpc: t.Optional[str] = None,
+) -> LedgerApi:
+    """Get default RPC chain type."""
+    if chain == Chain.SOLANA:  # TODO: Complete when Solana is supported
+        raise NotImplementedError("Solana not yet supported.")
+
+    gas_price_strategies = deepcopy(DEFAULT_GAS_PRICE_STRATEGIES)
+    if chain in (Chain.BASE, Chain.MODE, Chain.OPTIMISM):
+        gas_price_strategies[EIP1559]["fallback_estimate"]["maxFeePerGas"] = to_wei(
+            5, GWEI
+        )
+
+    ledger_api = make_ledger_api(
+        chain.ledger_type.name.lower(),
+        address=rpc or get_default_rpc(chain=chain),
+        chain_id=chain.id,
+        gas_price_strategies=gas_price_strategies,
+        poa_chain=chain == Chain.POLYGON,
+    )
+
+    if chain == Chain.OPTIMISM:
+        ledger_api.api.middleware_onion.inject(geth_poa_middleware, layer=0)
+
+    return ledger_api
+
+
+def get_default_ledger_api(chain: Chain) -> LedgerApi:
+    """Get default RPC chain type."""
+    if chain not in DEFAULT_LEDGER_APIS:
+        DEFAULT_LEDGER_APIS[chain] = make_chain_ledger_api(
+            chain=chain, rpc=get_default_rpc(chain=chain)
+        )
+    return DEFAULT_LEDGER_APIS[chain]
+
+
+GAS_ESTIMATE_FALLBACK_ADDRESSES = [
+    "0x000000000000000000000000000000000000dEaD",
+    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # nosec
+]
+GAS_ESTIMATE_BUFFER = 1.10
+
+
+# TODO backport to open aea/autonomy
+# TODO This gas pricing management should be done at a lower level in the library
+def update_tx_with_gas_pricing(tx: t.Dict, ledger_api: LedgerApi) -> None:
+    """Update transaction with gas pricing."""
+    tx.pop("maxFeePerGas", None)
+    tx.pop("gasPrice", None)
+    tx.pop("maxPriorityFeePerGas", None)
+
+    gas_pricing = ledger_api.try_get_gas_pricing()
+    if gas_pricing is None:
+        raise RuntimeError("Unable to retrieve gas pricing.")
+
+    if "maxFeePerGas" in gas_pricing and "maxPriorityFeePerGas" in gas_pricing:
+        tx["maxFeePerGas"] = gas_pricing["maxFeePerGas"]
+        tx["maxPriorityFeePerGas"] = gas_pricing["maxPriorityFeePerGas"]
+    elif "gasPrice" in gas_pricing:
+        tx["gasPrice"] = gas_pricing["gasPrice"]
+    else:
+        raise RuntimeError("Retrieved invalid gas pricing.")
+
+
+# TODO backport to open aea/autonomy
+# TODO This gas management should be done at a lower level in the library
+def update_tx_with_gas_estimate(tx: t.Dict, ledger_api: LedgerApi) -> None:
+    """Update transaction with gas estimate."""
+    print(f"[LEDGER] Trying to update transaction gas {tx['from']=} {tx['gas']=}.")
+    original_from = tx["from"]
+    original_gas = tx.get("gas", 1)
+
+    for address in [original_from] + GAS_ESTIMATE_FALLBACK_ADDRESSES:
+        tx["from"] = address
+        tx["gas"] = 1
+        ledger_api.update_with_gas_estimate(tx)
+        if tx["gas"] > 1:
+            print(f"[LEDGER] Gas estimated successfully {tx['from']=} {tx['gas']=}.")
+            break
+
+    tx["from"] = original_from
+    if tx["gas"] == 1:
+        tx["gas"] = original_gas
+        print(f"[LEDGER] Unable to estimate gas. Restored {tx['gas']=}.")
+    tx["gas"] = ceil(tx["gas"] * GAS_ESTIMATE_BUFFER)

operate/ledger/profiles.py

@@ -19,26 +19,329 @@
 
 """Chain profiles."""
 
-from operate.types import ChainType, ContractAddresses
-
-
-CONTRACTS = {
-    ChainType.GNOSIS: ContractAddresses(
-        {
-            "service_manager": "0x04b0007b2aFb398015B76e5f22993a1fddF83644",
-            "service_registry": "0x9338b5153AE39BB89f50468E608eD9d764B755fD",
-            "service_registry_token_utility": "0xa45E64d13A30a51b91ae0eb182e88a40e9b18eD8",
-            "gnosis_safe_proxy_factory": "0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE",
-            "gnosis_safe_same_address_multisig": "0x6e7f594f680f7aBad18b7a63de50F0FeE47dfD06",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        }
-    )
+import typing as t
+from functools import cache
+
+from autonomy.chain.base import registry_contracts
+from autonomy.chain.constants import CHAIN_PROFILES, DEFAULT_MULTISEND
+
+from operate.constants import NO_STAKING_PROGRAM_ID, ZERO_ADDRESS
+from operate.ledger import (
+    CHAINS,
+    NATIVE_CURRENCY_DECIMALS,
+    get_currency_denom,
+    get_default_ledger_api,
+)
+from operate.operate_types import Chain, ContractAddresses
+
+
+# TODO: Refactor, remove the usage of CONTRACTS and use CHAIN_PROFILES from Open Autonomy instead.
+CONTRACTS: t.Dict[Chain, ContractAddresses] = {}
+for _chain in CHAINS:
+    if _chain.value in CHAIN_PROFILES:
+        profile = CHAIN_PROFILES[_chain.value]
+        CONTRACTS[_chain] = ContractAddresses(
+            {
+                "service_registry": profile["service_registry"],
+                "service_registry_token_utility": profile[
+                    "service_registry_token_utility"
+                ],
+                "service_manager": profile["service_manager_token"],
+                "gnosis_safe_proxy_factory": profile["gnosis_safe_proxy_factory"],
+                "gnosis_safe_same_address_multisig": profile[
+                    "gnosis_safe_same_address_multisig"
+                ],
+                "safe_multisig_with_recovery_module": profile[
+                    "safe_multisig_with_recovery_module"
+                ],
+                "recovery_module": profile["recovery_module"],
+                "multisend": DEFAULT_MULTISEND,
+            }
+        )
+
+STAKING: t.Dict[Chain, t.Dict[str, str]] = {
+    Chain.ARBITRUM_ONE: {},
+    Chain.GNOSIS: {
+        "pearl_alpha": "0xEE9F19b5DF06c7E8Bfc7B28745dcf944C504198A",
+        "pearl_beta": "0xeF44Fb0842DDeF59D37f85D61A1eF492bbA6135d",
+        "pearl_beta_2": "0x1c2F82413666d2a3fD8bC337b0268e62dDF67434",
+        "pearl_beta_3": "0xBd59Ff0522aA773cB6074ce83cD1e4a05A457bc1",
+        "pearl_beta_4": "0x3052451e1eAee78e62E169AfdF6288F8791F2918",
+        "pearl_beta_5": "0x4Abe376Fda28c2F43b84884E5f822eA775DeA9F4",
+        "pearl_beta_6": "0x6C6D01e8eA8f806eF0c22F0ef7ed81D868C1aB39",
+        "pearl_beta_mech_marketplace": "0xDaF34eC46298b53a3d24CBCb431E84eBd23927dA",
+        "quickstart_beta_hobbyist": "0x389B46c259631Acd6a69Bde8B6cEe218230bAE8C",
+        "quickstart_beta_hobbyist_2": "0x238EB6993b90a978ec6AAD7530d6429c949C08DA",
+        "quickstart_beta_expert": "0x5344B7DD311e5d3DdDd46A4f71481bD7b05AAA3e",
+        "quickstart_beta_expert_2": "0xb964e44c126410df341ae04B13aB10A985fE3513",
+        "quickstart_beta_expert_3": "0x80faD33Cadb5F53f9D29F02Db97D682E8b101618",
+        "quickstart_beta_expert_4": "0xaD9d891134443B443D7F30013c7e14Fe27F2E029",
+        "quickstart_beta_expert_5": "0xE56dF1E563De1B10715cB313D514af350D207212",
+        "quickstart_beta_expert_6": "0x2546214aEE7eEa4bEE7689C81231017CA231Dc93",
+        "quickstart_beta_expert_7": "0xD7A3C8b975f71030135f1a66e9e23164d54fF455",
+        "quickstart_beta_expert_8": "0x356C108D49C5eebd21c84c04E9162de41933030c",
+        "quickstart_beta_expert_9": "0x17dBAe44BC5618Cc254055b386A29576b4F87015",
+        "quickstart_beta_expert_10": "0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f",
+        "quickstart_beta_expert_11": "0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7",
+        "quickstart_beta_expert_12": "0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc",
+        "quickstart_beta_expert_15_mech_marketplace": "0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1",
+        "quickstart_beta_expert_16_mech_marketplace": "0x6c65430515c70a3f5E62107CC301685B7D46f991",
+        "quickstart_beta_expert_17_mech_marketplace": "0x1430107A785C3A36a0C1FC0ee09B9631e2E72aFf",
+        "quickstart_beta_expert_18_mech_marketplace": "0x041e679d04Fc0D4f75Eb937Dea729Df09a58e454",
+        "pearl_beta_mech_marketplace_1": "0xAb10188207Ea030555f53C8A84339A92f473aa5e",
+        "pearl_beta_mech_marketplace_2": "0x8d7bE092d154b01d404f1aCCFA22Cef98C613B5D",
+        "pearl_beta_mech_marketplace_3": "0x9D00A0551F20979080d3762005C9B74D7Aa77b85",
+        "pearl_beta_mech_marketplace_4": "0xE2f80659dB1069f3B6a08af1A62064190c119543",
+        "quickstart_beta_mech_marketplace_expert_1": "0xdB9E2713c3dA3C403F2eA6E570eB978b00304e9E",
+        "quickstart_beta_mech_marketplace_expert_2": "0x1E90522b45c771DCF5f79645B9e96551d2ECaF62",
+        "quickstart_beta_mech_marketplace_expert_3": "0x75EECA6207be98cAc3fDE8a20eCd7B01e50b3472",
+        "quickstart_beta_mech_marketplace_expert_4": "0x9c7F6103e3a72E4d1805b9C683Ea5B370Ec1a99f",
+        "quickstart_beta_mech_marketplace_expert_5": "0xcdC603e0Ee55Aae92519f9770f214b2Be4967f7d",
+        "quickstart_beta_mech_marketplace_expert_6": "0x22D6cd3d587D8391C3aAE83a783f26c67ab54A85",
+        "quickstart_beta_mech_marketplace_expert_7": "0xaaEcdf4d0CBd6Ca0622892Ac6044472f3912A5f3",
+        "quickstart_beta_mech_marketplace_expert_8": "0x168aED532a0CD8868c22Fc77937Af78b363652B1",
+        "quickstart_beta_mech_marketplace_expert_9": "0xdDa9cD214F12e7C2D58E871404A0A3B1177065C8",
+        "quickstart_beta_mech_marketplace_expert_10": "0x53a38655B4e659eF4C7F88A26fbF5c67932C7156",
+        "mech_marketplace": "0x998dEFafD094817EF329f6dc79c703f1CF18bC90",
+        "marketplace_supply_alpha": "0xCAbD0C941E54147D40644CF7DA7e36d70DF46f44",
+        "marketplace_demand_alpha_1": "0x9d6e7aB0B5B48aE5c146936147C639fEf4575231",
+        "marketplace_demand_alpha_2": "0x9fb17E549FefcCA630dd92Ea143703CeE4Ea4340",
+    },
+    Chain.OPTIMISM: {
+        "optimus_alpha_1": "0x88996bbdE7f982D93214881756840cE2c77C4992",
+        "optimus_alpha_2": "0xBCA056952D2A7a8dD4A002079219807CFDF9fd29",
+        "optimus_alpha_3": "0x0f69f35652B1acdbD769049334f1AC580927E139",
+        "optimus_alpha_4": "0x6891Cf116f9a3bDbD1e89413118eF81F69D298C3",
+    },
+    Chain.ETHEREUM: {},
+    Chain.BASE: {
+        "meme_base_alpha_2": "0xc653622FD75026a020995a1d8c8651316cBBc4dA",
+        "meme_base_beta": "0x6011E09e7c095e76980b22498d69dF18EB62BeD8",
+        "meme_base_beta_2": "0xfb7669c3AdF673b3A545Fa5acd987dbfdA805e22",
+        "meme_base_beta_3": "0xCA61633b03c54F64b6A7F1f9A9C0A6Feb231Cc4D",
+        "marketplace_supply_alpha": "0xB14Cd66c6c601230EA79fa7Cc072E5E0C2F3A756",
+        "marketplace_demand_alpha_1": "0x38Eb3838Dab06932E7E1E965c6F922aDfE494b88",
+        "marketplace_demand_alpha_2": "0xBE6E12364B549622395999dB0dB53f163994D7AF",
+        "agents_fun_1": "0x2585e63df7BD9De8e058884D496658a030b5c6ce",
+        "agents_fun_2": "0x26FA75ef9Ccaa60E58260226A71e9d07564C01bF",
+        "agents_fun_3": "0x4D4233EBF0473Ca8f34d105A6256A2389176F0Ce",
+    },
+    Chain.CELO: {
+        "meme_celo_alpha_2": "0x95D12D193d466237Bc1E92a1a7756e4264f574AB",
+    },
+    Chain.MODE: {
+        "optimus_alpha": "0x5fc25f50E96857373C64dC0eDb1AbCBEd4587e91",
+        "modius_alpha": "0x534C0A05B6d4d28d5f3630D6D74857B253cf8332",
+        "modius_alpha_2": "0xeC013E68FE4B5734643499887941eC197fd757D0",
+        "modius_alpha_3": "0x9034D0413D122015710f1744A19eFb1d7c2CEB13",
+        "modius_alpha_4": "0x8BcAdb2c291C159F9385964e5eD95a9887302862",
+    },
+    Chain.POLYGON: {},
 }
 
-STAKING = {
-    ChainType.GNOSIS: "0xEE9F19b5DF06c7E8Bfc7B28745dcf944C504198A",
+
+DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priority mech address and service id
+    "0x4554fE75c1f5576c1d7F765B2A036c199Adae329": (
+        "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053",
+        975,
+    ),
+    "0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB": (
+        "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
+        2182,
+    ),
 }
 
-OLAS = {
-    ChainType.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
+
+# ERC20 token addresses
+OLAS: t.Dict[Chain, str] = {
+    Chain.ARBITRUM_ONE: "0x064F8B858C2A603e1b106a2039f5446D32dc81c1",
+    Chain.BASE: "0x54330d28ca3357F294334BDC454a032e7f353416",
+    Chain.CELO: "0xaCFfAe8e57Ec6E394Eb1b41939A8CF7892DbDc51",
+    Chain.ETHEREUM: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
+    Chain.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
+    Chain.MODE: "0xcfD1D50ce23C46D3Cf6407487B2F8934e96DC8f9",
+    Chain.OPTIMISM: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    Chain.POLYGON: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
 }
+
+USDC: t.Dict[Chain, str] = {
+    Chain.ARBITRUM_ONE: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    Chain.BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    Chain.CELO: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
+    Chain.ETHEREUM: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    Chain.GNOSIS: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
+    Chain.MODE: "0xd988097fb8612cc24eeC14542bC03424c656005f",
+    Chain.OPTIMISM: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    Chain.POLYGON: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+}
+
+WRAPPED_NATIVE_ASSET = {
+    Chain.ARBITRUM_ONE: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    Chain.BASE: "0x4200000000000000000000000000000000000006",
+    Chain.CELO: "0x471EcE3750Da237f93B8E339c536989b8978a438",  # Dual token
+    Chain.ETHEREUM: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    Chain.GNOSIS: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
+    Chain.MODE: "0x4200000000000000000000000000000000000006",
+    Chain.OPTIMISM: "0x4200000000000000000000000000000000000006",
+    Chain.POLYGON: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+}
+
+ERC20_TOKENS = {
+    "OLAS": OLAS,
+    "USDC": USDC,
+    "WRAPPED_NATIVE": WRAPPED_NATIVE_ASSET,
+}
+
+DUST = {
+    Chain.ARBITRUM_ONE: int(1e14),
+    Chain.BASE: int(1e14),
+    Chain.CELO: int(1e15),
+    Chain.ETHEREUM: int(1e14),
+    Chain.GNOSIS: int(1e15),
+    Chain.MODE: int(1e14),
+    Chain.OPTIMISM: int(1e14),
+    Chain.POLYGON: int(1e14),
+}
+
+DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
+    Chain.ARBITRUM_ONE: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
+    Chain.BASE: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
+    Chain.CELO: {
+        ZERO_ADDRESS: int(1e18),
+    },
+    Chain.ETHEREUM: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
+    Chain.GNOSIS: {
+        ZERO_ADDRESS: int(1e18),
+    },
+    Chain.MODE: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
+    Chain.OPTIMISM: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
+    Chain.POLYGON: {
+        ZERO_ADDRESS: int(1e18),
+    },
+}
+
+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},
+}
+
+DEFAULT_EOA_TOPUPS_WITHOUT_SAFE = {
+    chain: {asset: amount * 2 for asset, amount in amounts.items()}
+    for chain, amounts in DEFAULT_EOA_TOPUPS.items()
+}
+
+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},
+}
+
+DEFAULT_EOA_THRESHOLD = 0.5
+
+EXPLORER_URL = {
+    Chain.ARBITRUM_ONE: {
+        "tx": "https://arbiscan.io/tx/{tx_hash}",
+        "address": "https://arbiscan.io/address/{address}",
+    },
+    Chain.BASE: {
+        "tx": "https://basescan.org/tx/{tx_hash}",
+        "address": "https://basescan.org/address/{address}",
+    },
+    Chain.CELO: {
+        "tx": "https://celoscan.io/tx/{tx_hash}",
+        "address": "https://celoscan.io/address/{address}",
+    },
+    Chain.ETHEREUM: {
+        "tx": "https://etherscan.io/tx/{tx_hash}",
+        "address": "https://etherscan.io/address/{address}",
+    },
+    Chain.GNOSIS: {
+        "tx": "https://gnosisscan.io/tx/{tx_hash}",
+        "address": "https://gnosisscan.io/address/{address}",
+    },
+    Chain.MODE: {
+        "tx": "https://explorer.mode.network/tx/{tx_hash}",
+        "address": "https://explorer.mode.network/address/{address}",
+    },
+    Chain.OPTIMISM: {
+        "tx": "https://optimistic.etherscan.io/tx/{tx_hash}",
+        "address": "https://optimistic.etherscan.io/address/{address}",
+    },
+    Chain.POLYGON: {
+        "tx": "https://polygonscan.com/tx/{tx_hash}",
+        "address": "https://polygonscan.com/address/{address}",
+    },
+}
+
+
+@cache
+def get_asset_name(chain: Chain, asset_address: str) -> str:
+    """Get token name."""
+    if asset_address == ZERO_ADDRESS:
+        return get_currency_denom(chain)
+
+    if WRAPPED_NATIVE_ASSET.get(chain) == asset_address:
+        return f"W{get_currency_denom(chain)}"
+
+    for symbol, tokens in ERC20_TOKENS.items():
+        if tokens.get(chain) == asset_address:
+            return symbol
+
+    return asset_address
+
+
+@cache
+def get_asset_decimals(chain: Chain, asset_address: str) -> int:
+    """Get token decimals."""
+    if asset_address == ZERO_ADDRESS:
+        return NATIVE_CURRENCY_DECIMALS
+    erc20_token = registry_contracts.erc20.get_instance(
+        ledger_api=get_default_ledger_api(chain),
+        contract_address=asset_address,
+    )
+    return erc20_token.functions.decimals().call()
+
+
+def format_asset_amount(
+    chain: Chain, asset_address: str, amount: int, precision: int = 4
+) -> str:
+    """Convert smallest unit to human-readable string with token symbol."""
+    decimals = get_asset_decimals(chain, asset_address)
+    symbol = get_asset_name(chain, asset_address)
+    value = amount / (10**decimals)
+    return f"{value:.{precision}f} {symbol}"
+
+
+# TODO: Deprecate in favour of StakingManager method
+def get_staking_contract(
+    chain: str, staking_program_id: t.Optional[str]
+) -> t.Optional[str]:
+    """Get staking contract based on the config and the staking program."""
+    if staking_program_id == NO_STAKING_PROGRAM_ID or staking_program_id is None:
+        return None
+
+    return STAKING[Chain(chain)].get(
+        staking_program_id,
+        staking_program_id,
+    )