web3-wizzard-lib 0.0.2__py3-none-any.whl

web3_wizzard_lib/core/modules/bank/layerbank.py

@@ -0,0 +1,116 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.layerbank_price import LayerBankPrice
+from web3_wizzard_lib.core.contract.layerbank_token import LayerBankToken
+from web3_wizzard_lib.core.contract.layerbankcontract import LayerBankContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class LayerBank(Bank):
+    app_name = 'LAYERBANK'
+    supported_chains = ['LINEA']
+
+    def __init__(self, chain, web3):
+        self.chain = chain
+        self.web3 = web3
+        self.layerbank = LayerBankContract(get_contracts_for_chain(chain)["LAYERBANK"], web3)
+
+        lbwstETH = get_tokens_for_chain(chain)['lbwstETH']
+        self.lbWstETHToken = LayerBankToken(lbwstETH, web3)
+
+        lbETH = get_tokens_for_chain(chain)['lbETH']
+        self.lbETHToken = LayerBankToken(lbETH, web3)
+
+    def supply(self, account, token):
+        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
+
+        erc20_token = Erc20Token(self.chain, token, self.web3)
+        amount = erc20_token.balance(account)
+
+        if 25 * token.one_decimal() <= self.layerbank.account_liquidity_of(account)[0]:
+            logger.info("Already supplied over 25$ worth, skip this step")
+            return
+
+        if erc20_token.allowance(account, token.contract_address) < amount.wei:
+            erc20_token.approve(account, token.contract_address)
+
+        if amount.wei > 0:
+            if token.contract_address not in self.layerbank.market_list_of(account):
+                logger.info("Add support wstETH to LayerBank")
+                self.layerbank.enter_markets(account, token.contract_address)
+
+            logger.info(f"Supply {amount.log_line()}")
+
+            self.layerbank.supply(account, token.contract_address, amount.wei)
+
+        if 25 * token.one_decimal() > self.layerbank.account_liquidity_of(account)[0]:
+            raise Exception(
+                f"Not enough supply for 25$ borrow {self.layerbank.account_liquidity_of(account)[0] / token.one_decimal()}"
+            )
+
+    def borrow(self, account, token):
+        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
+
+        layerbank_price = LayerBankPrice(get_contracts_for_chain(self.chain)["LAYERBANK_PRICE"], self.web3)
+
+        usd_collateral = self.layerbank.account_liquidity_of(account)[0]
+        eth_amount = (usd_collateral / layerbank_price.get_underlying_price(token.contract_address))
+
+        logger.info(f"Borrow {eth_amount} {token.symbol()}")
+
+        borrow_amount = int(
+            eth_amount * token.one_decimal() * token.one_decimal() / token.exchange_rate())
+
+        self.layerbank.borrow(
+            account,
+            token.contract_address,
+            borrow_amount
+        )
+
+    def repay_borrow(self, account, token):
+        token = LayerBankToken(get_tokens_for_chain(self.chain)[token], self.web3)
+
+        layerbank_price = LayerBankPrice(get_contracts_for_chain(self.chain)["LAYERBANK_PRICE"], self.web3)
+
+        borrowed_usdc = self.layerbank.account_liquidity_of(account)[2]
+        lbETHPrice = layerbank_price.get_underlying_price(token.contract_address)
+        ethAmount = int(
+            (
+                    borrowed_usdc / lbETHPrice) * token.one_decimal() * token.one_decimal() / token.exchange_rate()
+        )
+
+        if 2 * token.one_decimal() > borrowed_usdc:
+            logger.info("Less than 2$ borrowed, skip")
+            return
+
+        logger.info(f"Repay Borrow {ethAmount / token.one_decimal()}")
+        self.layerbank.repay_borrow(account, token.contract_address, ethAmount)
+
+    def redeem(self, account, amount, token):
+        if token == 'ETH':
+            token = self.lbETHToken
+        elif token == 'wstETH':
+            token = self.lbWstETHToken
+
+        underlying_balance = self.get_deposit_amount(account, token)
+
+        if underlying_balance < 10000:
+            logger.info("Less than 0.001$ supplied, skip")
+            return
+
+        self.layerbank.redeem_token(
+            account,
+            token.contract_address,
+            int(underlying_balance * token.one_decimal() * 0.999 / token.exchange_rate())
+        )
+
+    def get_deposit_amount(self, account, token):
+        if token == 'ETH':
+            token = self.lbETHToken
+        elif token == 'wstETH':
+            token = self.lbWstETHToken
+
+        return token.underlying_balance_of(account)

web3_wizzard_lib/core/modules/bank/mendi_finance.py

@@ -0,0 +1,57 @@
+from loguru import logger
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.mendi_token import MendiTokenContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class MendiFinance(Bank):
+    app_name = 'MENDI_FINANCE'
+    supported_chains = ['LINEA']
+
+    def __init__(self, chain, web3):
+        self.chain = chain
+        self.web3 = web3
+
+    def supply(self, account, amount):
+        erc20 = Erc20Token(self.chain, amount.token, self.web3)
+        amount = erc20.balance(account)
+
+        me_token = f'me{amount.token}'
+        mendi_token_address = get_tokens_for_chain(self.chain)[me_token]
+
+        logger.info(f"Mendi supply {amount} {amount.token}")
+
+        if erc20.allowance(account, mendi_token_address) < erc20.balance(account).wei:
+            erc20.approve(account, mendi_token_address)
+
+        mendi = MendiTokenContract(mendi_token_address, self.web3)
+        mendi.mint(account, amount.wei)
+
+    def borrow(self, account, amount):
+        logger.info(f"Mendi borrow {amount.token}")
+
+    def repay_borrow(self, account, amount):
+        logger.info(f"Mendi repay {amount.token}")
+
+    def redeem(self, account, amount):
+        me_token = f'me{amount.token}'
+        mendi_token_address = get_tokens_for_chain(self.chain)[me_token]
+        mendi = MendiTokenContract(mendi_token_address, self.web3)
+
+        redeem_balance = mendi.balance_of(account)
+
+        if redeem_balance > 1000000000:
+            logger.info(f"Mendi reedem {amount. token}")
+            mendi.redeem(account, redeem_balance)
+        else:
+            logger.info(f"Mendi balance is 0")
+
+    def get_deposit_amount(self, account, token):
+        #me_token = f'meweETH'
+        mendi_token_address = get_tokens_for_chain(self.chain)[token]
+        mendi = MendiTokenContract(mendi_token_address, self.web3)
+
+        return mendi.balance_of(account)
+

web3_wizzard_lib/core/modules/bank/reactorfusion.py

@@ -0,0 +1,25 @@
+from sybil_engine.contract.weth import WETH
+from sybil_engine.data.networks import get_ids_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+
+from web3_wizzard_lib.core.contract.reactor_fusion_contract import ReactorFusionContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class ReactorFusion(Bank):
+    app_name = 'REACTORFUSION_LANDING'
+    supported_chains = ['ZKSYNC']
+
+    def __init__(self, contract, web3):
+        self.contract = ReactorFusionContract(contract, web3)
+
+    def supply(self, account, amount):
+        self.contract.mint(account, amount.wei)
+
+    def redeem(self, account, withdraw):
+        self.contract.redeem_underlying(account, withdraw.wei)
+
+    def get_deposit_amount(self, account, token):
+        weth_token = get_tokens_for_chain(get_ids_chain()[self.contract.web3.eth.chain_id])['REACTORFUSION_LANDING']
+
+        return WETH(weth_token, self.contract.web3).balance_of(account)

web3_wizzard_lib/core/modules/bank/zerolend.py

@@ -0,0 +1,36 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.tokens import Erc20Token
+
+from web3_wizzard_lib.core.contract.zerolend_contract import ZeroLendContract
+from web3_wizzard_lib.core.modules.bank.bank import Bank
+
+
+class ZeroLend(Bank):
+    app_name = 'ZEROLEND'
+    supported_chains = ['LINEA']
+
+    def __init__(self, chain, web3):
+        self.chain = chain
+        self.web3 = web3
+        self.contract = ZeroLendContract(get_contracts_for_chain(self.chain)['ZEROLEND_LEND'], self.web3)
+
+    def supply(self, account, amount):
+        logger.info(f"Deposit {amount} to ZEROLEND")
+
+        self.contract.deposit_eth(account, amount.wei)
+
+    def redeem(self, account, amount):
+        erc20_token = Erc20Token('LINEA', get_tokens_for_chain(self.chain)['ZEROLEND_WETH'], self.web3)
+
+        if erc20_token.allowance(account, self.contract.contract_address) < 100:
+            erc20_token.approve(account, self.contract.contract_address)
+
+        self.contract.withdraw_eth(account, amount.wei)
+
+    def get_deposit_amount(self, account, token):
+        erc20_token = Erc20Token('LINEA', get_tokens_for_chain(self.chain)['ZEROLEND_WETH'], self.web3)
+
+        return erc20_token.balance(account)
+

web3_wizzard_lib/core/modules/bridge/bridge.py

@@ -0,0 +1,8 @@
+class Bridge:
+    module_name = None
+
+    def execute(self, *args):
+        pass
+
+    def log(self):
+        pass

web3_wizzard_lib/core/modules/bridge/coredao_bridge_sub.py

@@ -0,0 +1,47 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance import NotEnoughERC20Balance
+from sybil_engine.domain.balance.balance_utils import interval_to_erc20_balance, get_native_balance
+from sybil_engine.domain.balance.tokens import Erc20Token
+from sybil_engine.utils.retry import retry
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.coredao_contract import CoreDaoContract
+from web3_wizzard_lib.core.contract.coredao_from_contract import CoreDaoFromContract
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+
+class CoreDaoBridgeSubModule(Bridge):
+    supported_chains = ['POLYGON', 'COREDAO']
+
+    @retry(max_attempts=5, retry_interval={'from': 60 * 15, 'to': 60 * 25})
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        erc20_token = Erc20Token(from_chain, token, web3)
+
+        amount = interval_to_erc20_balance(bridge_amount_interval, account, token, from_chain, web3)
+
+        logger.info(f"Native balance: {get_native_balance(account, web3, chain_instance)}")
+        logger.info(f"Balance: {erc20_token.balance(account)}")
+
+        logger.info(f"Bridge {from_chain + ' -> ' + to_chain} {amount}")
+
+        if amount.wei == 0:
+            raise NotEnoughERC20Balance(f"Can't swap zero balance")
+
+        coredao_contract = get_contracts_for_chain(from_chain)['COREDAO_BRIDGE']
+
+        if erc20_token.allowance(account, coredao_contract) < amount.wei:
+            erc20_token.approve(account, coredao_contract)
+
+        if from_chain == 'COREDAO':
+            coredao = CoreDaoFromContract(coredao_contract, web3)
+            fee = coredao.estimate_bridge_fee(to_chain)
+        else:
+            coredao = CoreDaoContract(coredao_contract, web3)
+            fee = coredao.estimate_bridge_fee()
+
+        coredao.bridge(account, amount, erc20_token.erc20_contract.contract_address, fee, to_chain)

web3_wizzard_lib/core/modules/bridge/orbiter_sub.py

@@ -0,0 +1,112 @@
+import random
+
+from loguru import logger
+from sybil_engine.contract.erc20contract import Erc20Contract
+from sybil_engine.contract.send import Send
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_erc20_balance, \
+    interval_to_native_balance, verify_balance
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.orbiter_starknet import OrbiterStarknet
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+bridge_codes = {
+    "ETH": 9001,
+    "ARBITRUM": 9002,
+    "POLYGON": 9006,
+    "OPTIMISM": 9007,
+    "BSC": 9015,
+    "ARBITRUM_NOVA": 9016,
+    "ZKSYNC": 9014,
+    "POLYGON_ZK": 9017,
+    "BASE": 9021,
+    "LINEA": 9023,
+    "SCROLL": 9019,
+    #"X_LAYER": 9027, DONT USE
+    "ZORA": 9030,
+    "MANTA": 9031,
+    "ZKFAIR": 9038
+}
+
+
+class OrbiterSubModule(Bridge):
+    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+
+        if isinstance(to_chain, list):
+            to_chain = random.choice(to_chain)
+        if to_chain not in bridge_codes:
+            raise ConfigurationException(f"{to_chain} not supported in orbiter")
+
+        amount = self.__calculate_bridge_amount(account, bridge_amount_interval, from_chain_instance, to_chain, token,
+                                                min_native_balance, web3)
+
+        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
+        self.__perform_bridge(account, amount, from_chain, to_chain, token, web3)
+
+    def __perform_bridge(self, account, amount, from_chain, to_chain, token, web3):
+        if token == 'NATIVE':
+            self.__bridge_native(account, amount, from_chain, to_chain, web3)
+        else:
+            self.__bridge_token(account, amount, from_chain, web3)
+
+    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, to_chain, token,
+                                  min_native_balance, web3):
+        if token == 'NATIVE':
+            native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+
+            amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+            if amount.wei > native_without_min.wei:
+                if bridge_amount_interval == 'all_balance':
+                    amount = native_without_min
+                else:
+                    raise NotEnoughNativeBalance(
+                        f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        else:
+            amount = interval_to_erc20_balance(bridge_amount_interval, account, token, from_chain_instance['chain'],
+                                               web3)
+            if bridge_amount_interval == 'all_balance':
+                amount.wei = amount.wei - 10 ** 5
+
+        amount.wei = self.__adjust_amount_by_bridge_code(amount.wei, to_chain)
+
+        return amount
+
+    def __adjust_amount_by_bridge_code(self, wei_amount, to_chain):
+        bridge_code = bridge_codes.get(to_chain)
+        if not bridge_code:
+            raise ConfigurationException(f"No bridge code found for {to_chain}")
+        return int(f"{wei_amount // 10 ** 4}{bridge_code}")
+
+    def __bridge_native(self, account, amount, from_chain, to_chain, web3):
+        if to_chain == 'STARKNET':
+            if amount.readable() <= 0.0065 or amount.readable() >= 5:
+                raise NotEnoughNativeBalance(f"Limit range amount for starknet 0.0065 – 5 ETH | {amount}")
+
+            if from_chain != 'ZKSYNC':
+                raise ConfigurationException("only ZKSYNC can bridge to STARKNET")
+
+            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER_STARKNET']
+            orbiter_starknet = OrbiterStarknet(orbiter_wallet, web3)
+            orbiter_starknet.bridge(account, amount)
+        else:
+            orbiter_wallet = get_contracts_for_chain(from_chain)['ORBITER']
+            send = Send(orbiter_wallet, web3)
+            send.send_to_wallet(account, orbiter_wallet, amount)
+
+    def __bridge_token(self, account, amount, from_chain, web3):
+        contracts = get_contracts_for_chain(from_chain)
+
+        if 'ORBITER_ERC20' not in contracts:
+            raise ConfigurationException(f"ERC20 is not supported for {from_chain}")
+
+        erc20 = Erc20Contract(get_tokens_for_chain(from_chain)[amount.token], web3)
+        erc20.transfer(account, amount, contracts['ORBITER_ERC20'])

web3_wizzard_lib/core/modules/bridge/scroll_bridge_sub.py

@@ -0,0 +1,42 @@
+from sybil_engine.utils.utils import ConfigurationException
+
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
+
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.eth_scroll_bridge_contract import EthScrollBridgeContract
+from web3_wizzard_lib.core.contract.scroll_bridge_contract import ScrollBridgeContract
+from web3_wizzard_lib.core.contract.scroll_oracle import ScrollOracle
+
+class ScrollBridgeSubModule(Bridge):
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+        if amount.wei > native_without_min.wei:
+            if bridge_amount_interval == 'all_balance':
+                amount = native_without_min
+            else:
+                raise NotEnoughNativeBalance(
+                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        if from_chain == 'ETH_MAINNET':
+            contract_oracle = get_contracts_for_chain(from_chain)["SCROLL_ORACLE"]
+            fee = ScrollOracle(contract_oracle, web3).estimateCrossDomainMessageFee()
+
+            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
+            scroll_bridge = EthScrollBridgeContract(scroll_bridge_contract_address, web3)
+
+            scroll_bridge.sendMessage(account, amount.wei, fee)
+        elif from_chain == 'SCROLL':
+            scroll_bridge_contract_address = get_contracts_for_chain(from_chain)["SCROLL_BRIDGE"]
+            scroll_bridge = ScrollBridgeContract(scroll_bridge_contract_address, web3)
+
+            scroll_bridge.withdraw(account, amount.wei)
+        else:
+            raise ConfigurationException(f"{from_chain} chain is unsupported, only ETH_MAINNET and SCROLL allowed")

web3_wizzard_lib/core/modules/bridge/stargate_v2_sub.py

@@ -0,0 +1,74 @@
+from loguru import logger
+from sybil_engine.data.contracts import get_contracts_for_chain
+from sybil_engine.data.networks import get_chain_instance
+from sybil_engine.domain.balance.balance import NotEnoughNativeBalance
+from sybil_engine.domain.balance.balance_utils import interval_to_native_balance, verify_balance
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.contract.stargate_v2_contract import StargateV2Contract
+from web3_wizzard_lib.core.modules.bridge.bridge import Bridge
+
+chain_ids = {
+    'LINEA': 30183,
+    'SCROLL': 30214,
+    'OPTIMISM': 30111,
+    'ARBITRUM': 30110,
+    'BASE': 30184
+}
+
+
+class StargateV2SubModule(Bridge):
+    supported_tokens = ['NATIVE']
+
+    def execute(self, bridge_amount_interval, from_chain, to_chain, token, min_native_balance, account):
+        if token != 'NATIVE':
+            raise ConfigurationException('Currently only native token bridge is supported by Stargate V2')
+
+        from_chain_instance = get_chain_instance(from_chain)
+        web3 = init_web3(from_chain_instance, account.proxy)
+        stargate_v2_contract = get_contracts_for_chain(from_chain)['STARGATE_V2']
+
+        amount = self.__calculate_bridge_amount(
+            account,
+            bridge_amount_interval,
+            from_chain_instance,
+            min_native_balance,
+            web3
+        )
+
+        logger.info(f"Bridge {from_chain} –> {to_chain} | {amount}")
+
+        send_params = (
+            chain_ids[to_chain],
+            f'0x000000000000000000000000{account.address[2:]}',
+            amount.wei,  # amountLD,
+            int(amount.wei * 0.995),  # minAmountLd,
+            b'',
+            b'',
+            b'\x01',
+        )
+
+        stargate_v2 = StargateV2Contract(stargate_v2_contract, web3)
+
+        stargate_fee = stargate_v2.quote_send(send_params)
+
+        stargate_v2.send(
+            account,
+            amount.wei + stargate_fee[0],
+            send_params,
+            stargate_fee,
+            account.address
+        )
+
+    def __calculate_bridge_amount(self, account, bridge_amount_interval, from_chain_instance, min_native_balance, web3):
+        native_without_min = verify_balance(min_native_balance, from_chain_instance, account, web3)
+
+        amount = interval_to_native_balance(bridge_amount_interval, account, from_chain_instance['chain'], web3)
+        if amount.wei > native_without_min.wei:
+            if bridge_amount_interval == 'all_balance':
+                amount = native_without_min
+            else:
+                raise NotEnoughNativeBalance(
+                    f"The account balance ({native_without_min}) < bridging amount ({amount}).")
+        return amount

web3_wizzard_lib/core/modules/bridge_module.py

@@ -0,0 +1,47 @@
+from sybil_engine.module.module import Module
+from sybil_engine.utils.utils import ConfigurationException
+from sybil_engine.utils.validation_utils import validate_amount_interval, validate_chain
+
+from web3_wizzard_lib.core.modules.bridge.coredao_bridge_sub import CoreDaoBridgeSubModule
+from web3_wizzard_lib.core.modules.bridge.orbiter_sub import OrbiterSubModule
+from web3_wizzard_lib.core.modules.bridge.scroll_bridge_sub import ScrollBridgeSubModule
+from web3_wizzard_lib.core.modules.bridge.stargate_v2_sub import StargateV2SubModule
+
+
+class BridgeModule(Module):
+    module_name = 'BRIDGE'
+    module_config = 'bridge_module'
+
+    supported_tokens = ['NATIVE', 'USDC', 'USDT', 'WETH']
+
+    def execute(self, bridge, bridge_amount_interval, from_chain, to_chain, token, account):
+        if bridge == 'ORBITER':
+            module = OrbiterSubModule()
+        elif bridge == 'STARGATE_V2':
+            module = StargateV2SubModule()
+        elif bridge == 'COREDAO':
+            module = CoreDaoBridgeSubModule()
+        elif bridge == 'SCROLL':
+            module = ScrollBridgeSubModule()
+        else:
+            raise ConfigurationException(f'Bridge {bridge} is not supported')
+
+        module.execute(bridge_amount_interval, from_chain, to_chain, token, self.min_native_balance, account)
+
+    def log(self):
+        return "BRIDGE"
+
+    def parse_params(self, module_params):
+        validate_amount_interval(module_params['bridge_amount_interval'])
+        validate_chain(module_params['from_chain'])
+
+        if 'token' not in module_params:
+            module_params['token'] = 'NATIVE'
+
+        if module_params['token'] not in self.supported_tokens:
+            raise ConfigurationException(
+                f"{module_params['token']} not supported in orbiter. Supported options: {self.supported_tokens}")
+
+        return module_params['bridge'], module_params['bridge_amount_interval'], module_params['from_chain'], \
+            module_params['to_chain'], \
+            module_params['token']