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

web3_wizzard_lib/core/contract/velocore_pool.py

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

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

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

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

web3_wizzard_lib/core/contract/yoddlo_contract.py

@@ -1,19 +0,0 @@
-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/yoddlo.json")
-
-
-class YoddloContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-
-    @evm_transaction
-    def purchase(self, account):
-        txn_params = self.build_generic_data(account.address, True)
-
-        txn_params['value'] = 100000000000000
-        txn_params['data'] = '0xfb89f3b1'
-
-        return txn_params

web3_wizzard_lib/core/contract/yuliverse_contract.py

@@ -1,36 +0,0 @@
-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/yoddlo.json")
-
-
-class YuliverseContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-
-    @evm_transaction
-    def purchase(self, account):
-        txn_params = self.build_generic_data(account.address, True)
-
-        function_selector = "0x064a181e"
-
-        # Example uint256 paramet er
-        varg0 = 123456789  # Make sure this is the value you intend to use
-
-        # Example bytes parameter (signature) - Ensure this is exactly 65 bytes
-        varg1 = b'Your65ByteSignatureHere'  # This should be the actual signature bytes
-
-        # Encoding the transaction data
-        data = function_selector
-        data += varg0.to_bytes(32, byteorder='big').hex()
-        data += (32).to_bytes(32, byteorder='big').hex()  # Offset for dynamic data
-        data += (65).to_bytes(32, byteorder='big').hex()  # Length of the signature
-        data += varg1.hex()
-
-        print(data)
-
-        # Concatenate the selector and the encoded parameters
-        txn_params['data'] = data
-
-        return txn_params

web3_wizzard_lib/core/contract/zebra_contract.py

@@ -1,68 +0,0 @@
-import time
-
-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/zebra.json")
-
-
-class ZebraContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-
-    def get_min_amount_out(self, amount, from_token: str, to_token: str):
-        min_amount_out = self.contract.functions.getAmountsOut(
-            amount.wei,
-            [
-                Web3.to_checksum_address(from_token),
-                Web3.to_checksum_address(to_token)
-            ]
-        ).call()
-        return min_amount_out[1]
-
-    @evm_transaction
-    def swap_to_token(self, account, amount, from_token: str, to_token: str, min_amount_out: int):
-        tx_data = self.build_generic_data(
-            account.address,
-            False
-        )
-
-        tx_data['value'] = amount.wei
-
-        deadline = int(time.time()) + 1000000
-
-        contract_txn = self.contract.functions.swapExactETHForTokens(
-            min_amount_out,
-            [
-                from_token,
-                to_token,
-            ],
-            account.address,
-            deadline
-        ).build_transaction(tx_data)
-
-        return contract_txn
-
-    @evm_transaction
-    def swap_to_eth(self, account, amount, from_token: str, to_token: str, min_amount_out: int):
-        tx_data = self.build_generic_data(
-            account.address,
-            False
-        )
-
-        deadline = int(time.time()) + 1000000
-
-        contract_txn = self.contract.functions.swapExactTokensForETH(
-            amount.wei,
-            min_amount_out,
-            [
-                from_token,
-                to_token,
-            ],
-            account.address,
-            deadline
-        ).build_transaction(tx_data)
-
-        return contract_txn

web3_wizzard_lib/core/contract/zerolend_contract.py

@@ -1,34 +0,0 @@
-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/zerolend.json")
-
-
-class ZeroLendContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-
-    @evm_transaction
-    def deposit_eth(self, account, amount):
-        sender = account.address
-        txn_params = self.build_generic_data(sender, False)
-
-        txn_params['value'] = amount
-
-        return self.contract.functions.depositETH(
-            '0x2f9bB73a8e98793e26Cb2F6C4ad037BDf1C6B269',
-            account.address,
-            0
-        ).build_transaction(txn_params)
-
-    @evm_transaction
-    def withdraw_eth(self, account, amount):
-        sender = account.address
-        txn_params = self.build_generic_data(sender, False)
-
-        return self.contract.functions.withdrawETH(
-            '0x2f9bB73a8e98793e26Cb2F6C4ad037BDf1C6B269',
-            int(amount * 0.98),
-            account.address
-        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/zerolend_liq_contract.py

@@ -1,20 +0,0 @@
-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/zerolend_liquidity.json")
-
-class ZeroLendLiqContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-
-    @evm_transaction
-    def create_lock(self, account, amount):
-        sender = account.address
-        txn_params = self.build_generic_data(sender, False)
-
-        return self.contract.functions.createLock(
-            int(amount.wei * 0.99),
-            31536000,
-            True
-        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/zkdx_contract.py

@@ -1,40 +0,0 @@
-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 ZKDXContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-        self.zkdx_token = '176211869ca2b568f2a7d4ee941e073a821ee1ff'
-
-    @evm_transaction
-    def swap_to_zkdx(self, account, amount):
-        sender = account.address
-        txn_params = self.build_generic_data(sender, True)
-
-        amount_hex = self.decimal_to_hex_padded(amount.wei)
-        txn_params[
-            'data'] = f'0x045d0389000000000000000000000000{self.zkdx_token}00000000000000000000000000000000{amount_hex}'
-
-        return txn_params
-
-    @evm_transaction
-    def swap_from_zkdx(self, account, amount):
-        sender = account.address
-        txn_params = self.build_generic_data(sender, True)
-
-        amount_hex = self.decimal_to_hex_padded(amount)
-
-        # txn_params['gas'] = 60000
-
-        txn_params[
-            'data'] = f'0x1e9a6950000000000000000000000000{self.zkdx_token}00000000000000000000000000000000{amount_hex}'
-
-        return txn_params
-
-    def decimal_to_hex_padded(self, decimal_number):
-        hex_number = hex(decimal_number)[2:]  # Remove the '0x' prefix
-        return hex_number.zfill(32)  # Pad with zeros to make the length 32

web3_wizzard_lib/core/contract/zkdx_data.py

@@ -1,14 +0,0 @@
-from sybil_engine.contract.contract import Contract
-from sybil_engine.utils.file_loader import load_abi
-
-abi = load_abi("resources/abi/zkdx_data.json")
-
-
-class ZKDXDataContract(Contract):
-    def __init__(self, contract_address, web3):
-        super().__init__(contract_address, web3, abi)
-        # self.zkdx_token = '0x176211869cA2b568f2A7D4EE941E073a821EE1ff'
-        self.zkdx_token = '0x2167C4D5FE05A1250588F0B8AA83A599e7732eae'
-
-    def get_balance(self, account):
-        return self.contract.functions.getTokenBalances(account.address, [self.zkdx_token]).call()

web3_wizzard_lib/core/contract/zks.py

@@ -1,24 +0,0 @@
-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/zks.json")
-
-
-class ZKS(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)
-
-        contract_txn = self.contract.functions.register(domain_name, sender, 1).build_transaction(txn_params)
-        contract_txn['gas'] = self.web3.eth.estimate_gas(contract_txn)
-
-        return contract_txn
-
-    def available(self, domain_name):
-        return self.contract.functions.available(domain_name).call()