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

web3_wizzard_lib/core/contract/syncswap_classic_pool_factory.py

@@ -0,0 +1,15 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/syncswap_classic_pool_factory.json")
+
+
+class SyncSwapClassicPoolFactory(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_pool(self, from_token, to_token):
+        return self.contract.functions.getPool(
+            from_token,
+            to_token
+        ).call()

web3_wizzard_lib/core/contract/syncswap_pool.py

@@ -0,0 +1,25 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/syncswap_pool.json")
+
+
+class SyncSwapPoolContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_amount_out(self, account, amount_to_swap, token_in_address):
+        sender = account.address
+
+        contract = self.web3.eth.contract(address=self.contract_address, abi=abi)
+
+        return contract.functions.getAmountOut(token_in_address, amount_to_swap.wei, sender).call()
+
+    def get_pool(self, from_token, to_token):
+        return self.contract.functions.getPool(
+            from_token,
+            to_token
+        ).call()
+
+    def balanceOf(self, account):
+        return self.contract.functions.balanceOf(account.address).call()

web3_wizzard_lib/core/contract/syncswap_router.py

@@ -0,0 +1,123 @@
+from datetime import datetime
+
+from eth_account.messages import encode_defunct
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.erc20contract import MAX_ALLOWANCE
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/syncswap_router.json")
+
+
+class SyncSwapRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def swap(self, account, amount_to_swap, token_in_data_address, token_in_address, pool_address, amount_out_min,
+             withdraw_mode=b'\x01'):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+        txn_params['value'] = amount_to_swap.wei if amount_to_swap.token == 'ETH' else 10000000000000
+
+        steps = self.steps(amount_to_swap, pool_address, sender, token_in_address, token_in_data_address,
+                           withdraw_mode)
+
+        paths = [{"steps": steps, "tokenIn": token_in_address, "amountIn": amount_to_swap.wei}]
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+
+        return self.contract.functions.swap(paths, amount_out_min, deadline).build_transaction(txn_params)
+
+    def steps(self, amount_to_swap, pool_address, sender, token_in_address, token_in_data_address, withdraw_mode):
+        if isinstance(pool_address, str):
+            data = b'\x00' * 12 + bytes.fromhex(token_in_data_address[2:]) + b'\x00' * 12 + bytes.fromhex(
+                sender[2:]) + b'\x00' * 31 + withdraw_mode
+
+            steps = [
+                {
+                    "pool": pool_address,
+                    "data": data,
+                    "callback": get_tokens_for_chain(amount_to_swap.chain)['ZERO_ADDRESS'],
+                    "callbackData": b''
+                }
+            ]
+        else:
+            usdc_address = get_tokens_for_chain(amount_to_swap.chain)['USDC']
+
+            pool_pairs = list(pool_address.items())
+            if amount_to_swap.token == 'USDT':
+                zero_pool = pool_pairs[0][1]  # USDC
+                first_pool = pool_pairs[1][1]  # USDT
+
+                data_fir_step = b'\x00' * 12 + bytes.fromhex(token_in_address[2:]) + b'\x00' * 12 + bytes.fromhex(
+                    sender[2:]) + b'\x00' * 31 + b'\x00'
+
+                data_sec_step = b'\x00' * 12 + bytes.fromhex(usdc_address[2:]) + b'\x00' * 12 + bytes.fromhex(
+                    sender[2:]) + b'\x00' * 31 + withdraw_mode
+            else:
+                zero_pool = pool_pairs[1][1]  # USDT
+                first_pool = pool_pairs[0][1]  # USDC
+
+                data_fir_step = b'\x00' * 12 + bytes.fromhex(
+                    token_in_data_address[2:]) + b'\x00' * 12 + bytes.fromhex(zero_pool[2:]) + b'\x00' * 31 + b'\x00'
+
+                data_sec_step = b'\x00' * 12 + bytes.fromhex(usdc_address[2:]) + b'\x00' * 12 + bytes.fromhex(
+                    sender[2:]) + b'\x00' * 31 + b'\x02'
+
+            steps = [
+                {
+                    "pool": first_pool,
+                    "data": data_fir_step,
+                    "callback": get_tokens_for_chain(amount_to_swap.chain)['ZERO_ADDRESS'],
+                    "callbackData": b''
+                },
+                {
+                    "pool": zero_pool,
+                    "data": data_sec_step,
+                    "callback": get_tokens_for_chain(amount_to_swap.chain)['ZERO_ADDRESS'],
+                    "callbackData": b''
+                }
+            ]
+
+        return steps
+
+    @evm_transaction
+    def add_liquidity2(self, account, amount):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        txn_params['value'] = amount.wei
+
+        return self.contract.functions.addLiquidity2(
+            '0x814A23B053FD0f102AEEda0459215C2444799C70',
+            [
+                (
+                    '0x0000000000000000000000000000000000000000',
+                    amount.wei
+                )
+            ],
+            f'0x000000000000000000000000{account.address[2:]}',
+            0,
+            '0x0000000000000000000000000000000000000000',
+            b'0x'
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def burn_liquidity(self, account, pool, amount):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        return self.contract.functions.burnLiquiditySingle(
+            pool,
+            amount.wei,  # liqudity
+            Web3.to_bytes(
+                hexstr=f'0x0000000000000000000000005300000000000000000000000000000000000004000000000000000000000000{account.address[2:]}0000000000000000000000000000000000000000000000000000000000000001'),
+            amount.wei,  # minAmount
+            Web3.to_bytes(hexstr='0x0000000000000000000000000000000000000000'),
+            b'0x'
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/tavaera_id.py

@@ -0,0 +1,18 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/tavaera_id.json")
+
+
+class TavaeraID(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def mint_citizen_id(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['value'] = Web3.to_wei(0.0003, "ether")
+
+        contract_txn = self.contract.functions.mintCitizenId().build_transaction(txn_params)
+
+        return contract_txn

web3_wizzard_lib/core/contract/tavaera_mint.py

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

web3_wizzard_lib/core/contract/townstory_bonus_contract.py

@@ -0,0 +1,19 @@
+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/townstory_bonus.json")
+
+
+class TownstoryBonusContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def claim_linea_travelbag(self, account, signature, deadline):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.claimLineaTravelbag(
+            signature, account.address, deadline
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/townstory_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
+from web3 import Web3
+
+abi = load_abi("resources/abi/townstory.json")
+
+
+class TownstoryContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def create_account_sign(self, account, signature, deadline):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.createAccountSign(
+            signature, 0, deadline
+        ).build_transaction(txn_params)
+
+        return contract_txn

web3_wizzard_lib/core/contract/velocore_lens.py

@@ -0,0 +1,44 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/velocore_lens.json")
+
+
+def to_bytes32(address):
+    return Web3.to_bytes(hexstr=address).rjust(32, b'\0')
+
+
+class VelocoreLensContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def getPoolBalance(self):
+        token_identifier = '0xe2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB'
+
+        # 0x000000000000000000000000e2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB
+
+        return (self.contract.functions.getPoolBalance(
+            '0xe2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB',
+            Web3.to_bytes(hexstr='0x000000000000000000000000b98308D11E2B578858Fbe65b793e71C7a0CAa43e')
+        )
+                .call())
+
+    def userBalances(self):
+        token_identifier = '0xe2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB'
+
+        # 0x000000000000000000000000e2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB
+        # 0x000000000000000000000000e2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB
+
+        return (self.contract.functions.userBalances(
+            '0xe2c67A9B15e9E7FF8A9Cb0dFb8feE5609923E5DB',
+            [Web3.to_bytes(hexstr='0x000000000000000000000000b98308D11E2B578858Fbe65b793e71C7a0CAa43e')]
+        )
+                .call())
+
+    def query_gauge(self, pool_address, account):
+        return (self.contract.functions.queryGauge(
+            pool_address,
+            account.address
+        )
+                .call())

web3_wizzard_lib/core/contract/velocore_pool.py

@@ -0,0 +1,198 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.data.tokens import get_tokens_for_chain
+
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/velocore_pool.json")
+
+
+def to_bytes32(address):
+    return Web3.to_bytes(hexstr=address).rjust(32, b'\0')
+
+
+class VelocorePoolContract(Contract):
+    ZERO = '0x0000000000000000000000000000000000000000000000000000000000000000'
+
+    def __init__(self, contract_address, web3):
+        self.LVC = get_tokens_for_chain('LINEA')['LVC']
+        self.VLP = get_tokens_for_chain('LINEA')['VLP']
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def deposit(self, account, amount, deposit_token, pool):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        amount_hex = '0x' + format(amount, '064x')
+        min_uint_256_hex = '00000000000000000000000000000000'
+        inverted_amount = self.invert_int(amount)
+        inverted_amount_hex = '0x' + min_uint_256_hex + inverted_amount
+
+        if deposit_token == 'ETH':
+            tokenRef = [
+                to_bytes32(self.VLP),
+                to_bytes32(self.LVC),
+                to_bytes32('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+            ]
+            deposit = [0, 0, 0]
+
+            txn_params['value'] = amount
+
+            ops = [
+                (
+                    to_bytes32(f'0x040000000000000000000000{sender[2:]}'),
+                    [to_bytes32('0x02000000000000000000000000000000' + format(amount, '032x'))],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'0x040000000000000000000000{sender[2:]}'),
+                    [to_bytes32('0x02000000000000000000000000000000' + inverted_amount)],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'000000000000000000000000{pool[2:]}'),
+                    [
+                        to_bytes32('000100000000000000000000000000007fffffffffffffffffffffffffffffff'),
+                        to_bytes32('020200000000000000000000000000007fffffffffffffffffffffffffffffff')
+                    ],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32('0500000000000000000000000000000000000000000000000000000000000000'),
+                    [to_bytes32('00010000000000000000000000000000ffffffffffffffffffffffffff785a9c')],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'010000000000000000000000{pool[2:]}'),
+                    [
+                        to_bytes32('000200000000000000000000000000007fffffffffffffffffffffffffffffff'),
+                        to_bytes32('0101000000000000000000000000000000000000000000000000000000000000')
+                    ],
+                    to_bytes32(self.ZERO)
+                )
+            ]
+        else:
+            wstETH = get_tokens_for_chain('LINEA')[deposit_token]
+            tokenRef = [
+                to_bytes32(wstETH),
+                to_bytes32(self.LVC),
+                to_bytes32(self.VLP),
+                to_bytes32('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+            ]
+            deposit = [amount, 0, 0, 0]
+
+            wstETHLP = '0x1D12E25e5516e5aD32F97fE9Edc332Bf4683f487'
+
+            ops = [
+                (
+                    to_bytes32(f'0x040000000000000000000000{sender[2:]}'),
+                    [to_bytes32(amount_hex)],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'0x040000000000000000000000{sender[2:]}'),
+                    [to_bytes32(inverted_amount_hex)],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'000000000000000000000000{wstETHLP[2:]}'),
+                    [
+                        to_bytes32('000200000000000000000000000000007fffffffffffffffffffffffffffffff'),
+                        to_bytes32('030100000000000000000000000000007fffffffffffffffffffffffffffffff')
+                    ],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'000000000000000000000000{pool[2:]}'),
+                    [
+                        to_bytes32('020100000000000000000000000000007fffffffffffffffffffffffffffffff'),
+                        to_bytes32('030200000000000000000000000000007fffffffffffffffffffffffffffffff')
+                    ],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32('0500000000000000000000000000000000000000000000000000000000000000'),
+                    [to_bytes32('02010000000000000000000000000000ffffffffffffffffffffffb4ad12f9cd')],
+                    to_bytes32(self.ZERO)
+                ),
+                (
+                    to_bytes32(f'010000000000000000000000{pool[2:]}'),
+                    [
+                        to_bytes32('0101000000000000000000000000000000000000000000000000000000000000'),
+                        to_bytes32('020200000000000000000000000000007fffffffffffffffffffffffffffffff')
+                    ],
+                    to_bytes32(self.ZERO)
+                )
+            ]
+
+        contract_txn = self.contract.functions.execute(tokenRef, deposit, ops).build_transaction(txn_params)
+
+        if self.web3.eth.chain_id == 59144:
+            contract_txn['gas'] = contract_txn['gas'] * 2
+
+        return contract_txn
+
+    @evm_transaction
+    def withdraw(self, account, eth_amount, eth_vlp, pool):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        tokenRef = [
+            to_bytes32(self.LVC),
+            to_bytes32(self.VLP),
+            to_bytes32('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+        ]
+        deposit = [0, 0, 0]
+
+        inverted_eth_amount = self.invert_int(eth_amount)
+        inverted_eth_vlp = self.invert_int(eth_vlp[0])
+
+        ops = [
+            (
+                to_bytes32(f'010000000000000000000000{pool[2:]}'),
+                [
+                    to_bytes32('0001000000000000000000000000000000000000000000000000000000000000'),
+                    to_bytes32(f'01000000000000000000000000000000{inverted_eth_vlp}')
+                ],
+                to_bytes32('0x0000000000000000000000000000000000000000000000000000000000000000')
+            ),
+            (
+                to_bytes32(f'000000000000000000000000{pool[2:]}'),
+                [
+                    to_bytes32('010200000000000000000000000000007fffffffffffffffffffffffffffffff'),
+                    to_bytes32('020100000000000000000000000000007fffffffffffffffffffffffffffffff')
+                ],
+                to_bytes32('0x0000000000000000000000000000000000000000000000000000000000000000')
+            ),
+            (
+                to_bytes32('0500000000000000000000000000000000000000000000000000000000000000'),
+                [to_bytes32(f'02010000000000000000000000000000{inverted_eth_amount}')],
+                to_bytes32('0x0000000000000000000000000000000000000000000000000000000000000000')
+            )
+        ]
+
+        contract_txn = self.contract.functions.execute(tokenRef, deposit, ops).build_transaction(txn_params)
+
+        if self.web3.eth.chain_id == 59144:
+            contract_txn['gas'] = contract_txn['gas'] * 2
+
+        return contract_txn
+
+    def allPairs(self):
+        return self.contract.functions.allPairs(1).call()
+
+    def facets(self):
+        return self.contract.functions.facets().call()
+
+    def invert_int(self, amount):
+        max_uint_256_hex = 'ffffffffffffffffffffffffffffffff'
+        hex_2 = int(max_uint_256_hex, 16) - amount + 1
+        hex_string = hex(hex_2)[2:].rjust(32, '0')
+
+        return hex_string
+# 5411000000000000
+# 5410999999999999

web3_wizzard_lib/core/contract/velocore_router.py

@@ -0,0 +1,80 @@
+from datetime import datetime
+
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from sybil_engine.data.networks import get_ids_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/velocore.json")
+
+
+class VelocoreRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def swap_exact_eth_for_tokens(self, account, amount_to_swap, token_in_address, token_out_address, amount_out_min):
+        sender = account.address
+
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        stable = False
+
+        txn_params = self.build_generic_data(sender)
+
+        txn_params['value'] = amount_to_swap.wei
+        txn_params['data'] = self.contract.encode_abi('swapExactETHForTokens', args=(
+            amount_out_min,
+            [[token_in_address, token_out_address, stable]],
+            sender,
+            deadline
+        )
+                                                     )
+
+        return txn_params
+
+    @evm_transaction
+    def swap_exact_tokens_for_eth(self, account, amount_to_swap, token_in_address, token_out_address, amount_out_min):
+        sender = account.address
+        txn_params = self.build_generic_data(account.address, False)
+
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        stable = False
+
+        return self.contract.functions.swapExactTokensForETH(
+            amount_to_swap.wei,
+            amount_out_min,
+            [[token_in_address, token_out_address, stable]],
+            sender,
+            deadline
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def swap_exact_tokens_for_tokens(self, account, amount_to_swap, token_in_address, token_out_address,
+                                     amount_out_min):
+        sender = account.address
+        txn_params = self.build_generic_data(sender)
+
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+
+        usdc_address = get_tokens_for_chain(get_ids_chain()[self.web3.eth.chain_id])['USDC']
+
+        if token_out_address != usdc_address:
+            stable = False
+        else:
+            stable = True
+
+        return self.contract.functions.swapExactTokensForTokens(
+            amount_to_swap.wei,
+            amount_out_min,
+            [[token_in_address, token_out_address, stable]],
+            sender,
+            deadline
+        ).build_transaction(txn_params)
+
+    def get_amount_out(self, amount_to_swap, token_in_address, token_out_address):
+        return self.contract.functions.getAmountOut(
+            amount_to_swap.wei,
+            token_in_address,
+            token_out_address
+        ).call()[0]

web3_wizzard_lib/core/contract/woofi_swap.py

@@ -0,0 +1,29 @@
+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/woofi.json")
+
+
+class WoofiSwap(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def swap(self, account, amount_to_swap, token_in_address, token_out_address, amount_out_min):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, False)
+
+        txn_params['value'] = amount_to_swap.wei if amount_to_swap.token == 'ETH' else 0
+
+        return self.contract.functions.swap(
+            token_in_address,
+            token_out_address,
+            amount_to_swap.wei,
+            amount_out_min,
+            sender,
+            sender
+        ).build_transaction(txn_params)
+
+    def query_swap(self, from_token, to_token, from_amount):
+        return self.contract.functions.querySwap(from_token, to_token, from_amount.wei).call()

web3_wizzard_lib/core/contract/xy_finance_contract.py

@@ -0,0 +1,87 @@
+import requests
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+from web3 import Web3
+
+
+class XYSwapContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, None)
+
+    def get_quote(self, from_token: str, to_token: str, amount: int, slippage: float):
+        url = "https://aggregator-api.xy.finance/v1/quote"
+
+        params = {
+            "srcChainId": self.web3.eth.chain_id,
+            "srcQuoteTokenAddress": Web3.to_checksum_address(from_token),
+            "srcQuoteTokenAmount": amount.wei,
+            "dstChainId": self.web3.eth.chain_id,
+            "dstQuoteTokenAddress": Web3.to_checksum_address(to_token),
+            "slippage": slippage
+        }
+
+        response = requests.get(url=url, params=params)
+        transaction_data = response.json()
+
+        return transaction_data
+
+    @evm_transaction
+    def swap(
+            self,
+            account,
+            amount_to_swap,
+            from_token: str,
+            to_token: str,
+            quote: int,
+            slippage: int
+    ):
+        amount_wei = amount_to_swap.wei
+
+        swap_provider = quote["routes"][0]["srcSwapDescription"]["provider"]
+
+        transaction_data = self.build_transaction(
+            account,
+            from_token,
+            to_token,
+            amount_wei,
+            slippage,
+            swap_provider
+        )
+
+        tx_data = self.build_generic_data(account.address, True)
+
+        tx_data.update(
+            {
+                "to": self.web3.to_checksum_address(transaction_data["tx"]["to"]),
+                "data": transaction_data["tx"]["data"],
+                "value": transaction_data["tx"]["value"],
+                "nonce": self.web3.eth.get_transaction_count(account.address)
+            }
+        )
+
+        return tx_data
+
+    def build_transaction(self, account, from_token: str, to_token: str, amount: int, slippage: float,
+                          swap_provider: str):
+        url = "https://aggregator-api.xy.finance/v1/buildTx"
+
+        params = {
+            "srcChainId": self.web3.eth.chain_id,
+            "srcQuoteTokenAddress": Web3.to_checksum_address(from_token),
+            "srcQuoteTokenAmount": amount,
+            "dstChainId": self.web3.eth.chain_id,
+            "dstQuoteTokenAddress": Web3.to_checksum_address(to_token),
+            "slippage": slippage,
+            "receiver": account.address,
+            "srcSwapProvider": swap_provider,
+        }
+
+        # if XYSWAP_CONTRACT["use_ref"]:
+        #     params.update({
+        #         "affiliate": Web3.to_checksum_address("0xb98308D11E2B578858Fbe65b793e71C7a0CAa43e"),
+        #         "commissionRate": 10000
+        #     })
+
+        response = requests.get(url=url, params=params)
+
+        return response.json()