web3-wizzard-lib 1.6.12__py3-none-any.whl → 1.6.14__py3-none-any.whl

web3_wizzard_lib/core/__init__.py

@@ -0,0 +1 @@
+

web3_wizzard_lib/core/contract/aavecontract.py

@@ -0,0 +1,36 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/aave.json")
+
+
+class AaveContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def depositETH(self, account, amount: int):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        txn_params['value'] = amount
+
+        return self.contract.functions.depositETH(
+            '0x11fCfe756c05AD438e312a7fd934381537D3cFfe',
+            account.address,
+            0
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def withdrawETH(self, account, amount: int):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.withdrawETH(
+            '0x11fCfe756c05AD438e312a7fd934381537D3cFfe',
+            amount,
+            account.address
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/alienswap_contract.py

@@ -0,0 +1,21 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/abbysworld.json")
+
+
+class AlienSwapContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def purchase(self, account, amount):
+        txn_params = self.build_generic_data(account.address, True)
+
+        txn_params['value'] = 100000000000000
+
+        txn_params['data'] = '0xefef39a10000000000000000000000000000000000000000000000000000000000000001'
+        txn_params['gasPrice'] = self.web3.eth.gas_price
+
+        return txn_params

web3_wizzard_lib/core/contract/arena_games_contract.py

@@ -0,0 +1,16 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/arena_games.json")
+
+
+class ArenaGamesContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def safe_mint(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.safeMint(account.address).build_transaction(txn_params)

web3_wizzard_lib/core/contract/basiliskcontract.py

@@ -0,0 +1,58 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/basiliks.json")
+
+
+class BasiliskContract(Contract):
+
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_deposit_amount(self, account):
+        return self.contract.functions.balanceOfUnderlying(account.address).call()
+
+    @evm_transaction
+    def mint(self, account, amount_wei):
+        tx_data = self.build_generic_data(account.address)
+
+        tx_data['data'] = self.contract.encode_abi('mint', args=())
+        tx_data['gas'] = int(self.web3.eth.estimate_gas(tx_data) * 1.1)
+
+        tx_data.update({"value": amount_wei})
+
+        return tx_data
+
+    @evm_transaction
+    def redeem_underlying(self, account, amount):
+        tx_data = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.redeemUnderlying(amount).build_transaction(tx_data)
+
+    # @evm_transaction
+    # def enable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Enable collateral on basilisk.py")
+    #
+    #     contract = self.get_contract(BASILISK_CONTRACTS["collateral"], BASILISK_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #
+    #     transaction = await contract.functions.enterMarkets(
+    #         [Web3.to_checksum_address(BASILISK_CONTRACTS["landing"])]
+    #     ).build_transaction(tx_data)
+    #
+    #     return transaction
+    #
+    # @evm_transaction
+    # def disable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Disable collateral on basilisk.py")
+    #
+    #     contract = self.get_contract(BASILISK_CONTRACTS["collateral"], BASILISK_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #     transaction = await contract.functions.exitMarket(
+    #         Web3.to_checksum_address(BASILISK_CONTRACTS["landing"])
+    #     ).build_transaction(tx_data)
+    #
+    #     return transaction

web3_wizzard_lib/core/contract/bilinear_contract.py

@@ -0,0 +1,22 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/bilinear.json")
+
+
+class BilinearContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def claim(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.claim(
+            [],
+            ([], [1]),
+            ([], [], []),
+            0,
+            '0x307b8d76e3a3ca16066982ae42768878ec07a1b9af2679f2f9b8a3c3db25e7d5'
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/bungee.py

@@ -0,0 +1,33 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/bungee.json")
+
+bungee_chain_ids = {
+    "BSC": 56,
+    "OPTIMISM": 10,
+    "POLYGON": 137,
+    "BASE": 8453,
+    "ARBITRUM": 42161,
+    "AVALANCHE": 43114,
+    "ZK_EVM": 1101,
+    "ZKSYNC": 324
+}
+
+
+class Bungee(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def refuel(self, account, to_chain, amount):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+        txn_params['value'] = amount
+
+        return self.contract.functions.depositNativeToken(
+            bungee_chain_ids[to_chain],
+            sender
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/coredao_contract.py

@@ -0,0 +1,34 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import l0_evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/coredao.json")
+
+class CoreDaoContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @l0_evm_transaction
+    def bridge(self, account, amount, token, fee, to_chain):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = fee
+
+        contract_txn = self.contract.functions.bridge(
+            token,
+            amount.wei,
+            account.address,
+            (
+                account.address,
+                '0x0000000000000000000000000000000000000000'
+            ),
+            b''
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    def estimate_bridge_fee(self):
+        return self.contract.functions.estimateBridgeFee(
+            False,
+            b''
+        ).call()[0]

web3_wizzard_lib/core/contract/coredao_from_contract.py

@@ -0,0 +1,40 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import l0_evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+from web3_wizzard_lib.core.modules.stargate.l0_data import l0_chain_ids
+
+abi = load_abi("resources/abi/coredao_bridge.json")
+
+
+class CoreDaoFromContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @l0_evm_transaction
+    def bridge(self, account, amount, token, fee, to_chain):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = fee
+
+        contract_txn = self.contract.functions.bridge(
+            token,
+            l0_chain_ids[to_chain],
+            amount.wei,
+            account.address,
+            False,
+            (
+                account.address,
+                '0x0000000000000000000000000000000000000000'
+            ),
+            b''
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    def estimate_bridge_fee(self, to_chain):
+        return self.contract.functions.estimateBridgeFee(
+            l0_chain_ids[to_chain],
+            False,
+            b''
+        ).call()[0]

web3_wizzard_lib/core/contract/dmail_send_mail.py

@@ -0,0 +1,18 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/dmail.json")
+
+
+class DmailSend(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def send_mail(self, account, to, subject):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        return self.contract.functions.send_mail(to, subject).build_transaction(txn_params)

web3_wizzard_lib/core/contract/empty_nft.py

@@ -0,0 +1,18 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/empty_nft.json")
+
+
+class EmptyNFT(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(self, account):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.mint().build_transaction(txn_params)

web3_wizzard_lib/core/contract/era_name.py

@@ -0,0 +1,23 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/era_ns.json")
+
+
+class EraName(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def register(self, account, domain_name):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+        txn_params['value'] = Web3.to_wei(0.003, "ether")
+
+        return self.contract.functions.Register(domain_name).build_transaction(txn_params)
+
+    def check_name(self, domain_name):
+        return self.contract.functions._checkName(domain_name).call()

web3_wizzard_lib/core/contract/eralendcontract.py

@@ -0,0 +1,34 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/eralend.json")
+
+
+class EraLendContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(self, account, amount: int):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender)
+        txn_params['data'] = 0x1249c58b
+        txn_params['gas'] = int(self.web3.eth.estimate_gas(txn_params))
+
+        txn_params['value'] = amount
+
+        return txn_params
+
+    @evm_transaction
+    def redeem_underlying(self, account, amount: int):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.redeemUnderlying(amount).build_transaction(txn_params)
+
+    def get_deposit_amount(self, account):
+        return self.contract.functions.balanceOfUnderlying(account.address).call()

web3_wizzard_lib/core/contract/eth_scroll_bridge_contract.py

@@ -0,0 +1,25 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/eth_scroll_bridge.json")
+
+
+class EthScrollBridgeContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def sendMessage(self, account, amount, fee):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = amount + fee
+
+        contract_txn = self.contract.functions.sendMessage(
+            account.address,
+            amount,
+            b'0x',
+            168000
+        ).build_transaction(txn_params)
+
+        return contract_txn

web3_wizzard_lib/core/contract/frog_war_contract.py

@@ -0,0 +1,48 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+from eth_abi import encode
+
+abi = load_abi("resources/abi/frog_war_contract.json")
+
+
+class FrogWarContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def claim(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = 100000000000000
+
+        return self.contract.functions.claim(
+            account.address,
+            1,
+            1,
+            '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+            100000000000000,
+            (
+                ['0x0000000000000000000000000000000000000000000000000000000000000000'],
+                # Note the brackets indicating an array
+                1,
+                0,
+                '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'
+            ),
+            '0x'
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def claim_bonus(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        _receiver = account.address
+        _tokenId = 6
+        _quantity = 1
+        _currency = '0x21d624c846725ABe1e1e7d662E9fB274999009Aa'
+        _pricePerToken = 0
+
+        return self.contract.functions.claim(
+            _receiver, _tokenId, _quantity, _currency, _pricePerToken,
+            [[encode(['bytes32'], [b''])], 1, _pricePerToken, _currency], b''
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/gmx_reward_router.py

@@ -0,0 +1,22 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/gmx_reward_router.json")
+
+
+class GmxRewardRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def unstake_and_redeem(self, account, glp_amount):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.unstakeAndRedeemGlpETH(
+            glp_amount,
+            0,
+            account.address,
+        ).build_transaction(txn_params)
+
+        return contract_txn

web3_wizzard_lib/core/contract/horizondex_quoter.py

@@ -0,0 +1,14 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/horizondex_quoter.json")
+
+
+class HorizonDexQuoter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def quote_exact_input_single(self, amount: int, from_token_address: str, to_token_address: str):
+        return self.contract.functions.quoteExactInputSingle(
+            (from_token_address, to_token_address, amount, 40, 0)
+        ).call()[1]

web3_wizzard_lib/core/contract/horizondex_router.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+swap_method_id = 'a8c9ed67'
+abi = load_abi("resources/abi/horizondex.json")
+
+
+class HorizonDexRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def multicall(self, account, amount_to_swap, amount_out_min, token_in_address, token_out_address):
+        txn_params = self.build_generic_data(account.address, set_contract_address=False)
+
+        if amount_to_swap.token == 'ETH':
+            txn_params['value'] = amount_to_swap.wei  # amount in for ETH
+
+        deadline_hex = decimal_to_padded_hexadecimal(int(datetime.now().timestamp() + 60 * 60 * 3), 64)
+        amount_in = decimal_to_padded_hexadecimal(amount_to_swap.wei, 64)
+        amount_out_min_hex = decimal_to_padded_hexadecimal(amount_out_min, 64)
+        token_in_address_padded = pad_hex(token_in_address, 64).lower()
+        token_out_address_padded = pad_hex(token_out_address, 64).lower()
+
+        if amount_to_swap.chain == 'BASE':
+            some_value = '000000000000000000000000000000000000000000000000000000000000000a'
+        else:
+            if amount_to_swap.token == 'USDC':
+                some_value = '000000000000000000000000000000000000000000000000000000000000012c'
+            else:
+                some_value = '0000000000000000000000000000000000000000000000000000000000000028'
+
+        swap = '0x' + swap_method_id + token_in_address_padded + token_out_address_padded + some_value + '0000000000000000000000000000000000000000000000000000000000000000' + deadline_hex + amount_in + amount_out_min_hex + '0000000000000000000000000000000000000000000000000000000000000000'
+        unwrapETH = self.contract.encode_abi("unwrapWeth", args=(amount_out_min, account.address))
+
+        return self.contract.functions.multicall([swap, unwrapETH]).build_transaction(txn_params)
+
+    @evm_transaction
+    def swap_exact_input_single(self, account, amount_to_swap, min_amount_out, token_in_address, token_out_address):
+        sender = account.address
+
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+        txn_params['value'] = amount_to_swap.wei
+
+        return self.contract.functions.swapExactInputSingle(
+            (
+                token_in_address,
+                token_out_address,
+                40,
+                sender,
+                deadline,
+                amount_to_swap.wei,
+                min_amount_out,
+                0
+            ),
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def swap_exact_input(self, account, min_amount_out, amount_to_swap, token_in_address, token_out_address):
+        sender = account.address
+
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        path = token_in_address + '00002842000000000000000000000000000000000000060003e8' + token_out_address
+
+        txn_params = self.build_generic_data(sender)
+        txn_params['value'] = amount_to_swap.wei
+        txn_params['data'] = self.contract.encode_abi('swapExactInput', args=(
+            (
+                path,
+                sender,
+                deadline,
+                amount_to_swap.wei,
+                min_amount_out
+            ),
+        )
+                                                     )
+        return txn_params
+
+
+def decimal_to_padded_hexadecimal(decimal_number, desired_length):
+    hex_value = hex(decimal_number)[2:]
+
+    return hex_value.zfill(desired_length)
+
+
+def pad_hex(un_padded_hex, desired_length):
+    return un_padded_hex[2:].zfill(desired_length)

web3_wizzard_lib/core/contract/imagine_contract.py

@@ -0,0 +1,18 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/imagine.json")
+
+
+class ImagineContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(self, account, uri):
+        amount = self.web3.to_wei(0.0001, "ether")
+        txn_params = self.build_generic_data(account.address, set_contract_address=False)
+        txn_params['value'] = amount
+
+        return self.contract.functions.mint(uri).build_transaction(txn_params)

web3_wizzard_lib/core/contract/izumi.py

@@ -0,0 +1,63 @@
+from datetime import datetime
+
+import requests
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+swap_method_id = 'ac9650d8'
+abi = load_abi("resources/abi/izumi.json")
+
+
+class IzumiRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def multicall(self, account, amount_to_swap, amount_out_min, token_in_address, token_out_address):
+        txn_params = self.build_generic_data(account.address, set_contract_address=True)
+
+        if amount_to_swap.token == 'ETH':
+            txn_params['value'] = amount_to_swap.wei  # amount in for ETH
+
+        amount_in = decimal_to_padded_hexadecimal(amount_to_swap.wei, 64)
+        deadline_hex = decimal_to_padded_hexadecimal(int(datetime.now().timestamp() + 60 * 60 * 3), 64)
+        amount_out_min_hex = decimal_to_padded_hexadecimal(amount_out_min, 64)
+        token_in_address = token_in_address[2:].lower()
+        token_out_address = token_out_address[2:].lower()
+
+        sender_padded = pad_hex(account.address, 64).lower()
+
+        if amount_to_swap.token == 'ETH':
+            swap_method = f'0x{swap_method_id}00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000012475ceafe6000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000a0{sender_padded}{amount_in}{amount_out_min_hex}{deadline_hex}000000000000000000000000000000000000000000000000000000000000002b{token_in_address}000bb8{token_out_address}00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+            refund_method = '412210e8a00000000000000000000000000000000000000000000000000000000'
+            txn_params['data'] = swap_method + refund_method
+        else:
+            swap_method = f'0x{swap_method_id}00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000012475ceafe6000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000{amount_in}{amount_out_min_hex}{deadline_hex}000000000000000000000000000000000000000000000000000000000000002b{token_in_address}000bb8{token_out_address}000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044'
+            unwrap_method = f'49404b7c0000000000000000000000000000000000000000000000000000000000000000{sender_padded}00000000000000000000000000000000000000000000000000000000'
+            txn_params['data'] = swap_method + unwrap_method
+
+        return txn_params
+
+    def quote_price(self, token):
+        BASE_URL = 'https://api.izumi.finance/api/v1/token_info/price_info/?t=USDC&t=ETH&t=WETH&t=wstETH&t=weETH'
+        response = requests.get(BASE_URL)
+
+        if response.status_code == 200:
+            data = response.json()
+            tokenPrice, ETH = float(data['data'][token]), float(data['data']['ETH'])
+
+            return ETH / tokenPrice
+        else:
+            print(f"Error {response.status_code}: {response.text}")
+            return None
+
+
+def decimal_to_padded_hexadecimal(decimal_number, desired_length):
+    hex_value = hex(decimal_number)[2:]
+
+    return hex_value.zfill(desired_length)
+
+
+def pad_hex(un_padded_hex, desired_length):
+    return un_padded_hex[2:].zfill(desired_length)