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

core/modules/bank/layerbank.py

@@ -1,116 +0,0 @@
-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)

core/modules/bank/mendi_finance.py

@@ -1,57 +0,0 @@
-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)
-

core/modules/bank/reactorfusion.py

@@ -1,25 +0,0 @@
-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)

core/modules/bank/zerolend.py

@@ -1,36 +0,0 @@
-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)
-

core/modules/bridge/bridge.py

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

core/modules/bridge/coredao_bridge_sub.py

@@ -1,47 +0,0 @@
-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)

core/modules/bridge/orbiter_sub.py

@@ -1,112 +0,0 @@
-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'])

core/modules/bridge/scroll_bridge_sub.py

@@ -1,42 +0,0 @@
-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")

core/modules/bridge/stargate_v2_sub.py

@@ -1,74 +0,0 @@
-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

core/modules/bridge_module.py

@@ -1,47 +0,0 @@
-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']