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

web3_wizzard_lib/core/contract/maverick_multicall.py

@@ -0,0 +1,52 @@
+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
+
+swap_method_id = 'c04b8d59'
+
+length_3c = '000000000000000000000000000000000000000000000000000000000000003c'
+universal_value = '000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000a0'
+
+abi = load_abi("resources/abi/maverick_multicall.json")
+
+
+class MaverickMulticall(Contract):
+    def __init__(self, contract_address, web3):
+        self.weth_token = get_tokens_for_chain(get_ids_chain()[web3.eth.chain_id])['WETH']
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def multicall(self, account, amount_to_swap, amount_out_min_in, token_in_address, pool_address, token_out_address):
+        txn_params = self.build_generic_data(account.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 = decimal_to_padded_hexadecimal(amount_out_min_in, 64)
+        recipient = pad_hex(account.address, 64) if token_out_address != self.weth_token else pad_hex('', 64)
+
+        eth_to_usdc = '0x' + swap_method_id + universal_value + recipient + deadline_hex + amount_in + amount_out_min + length_3c + pad_hex(
+            token_in_address, 40) + pad_hex(pool_address, 40) + pad_hex(token_out_address, 40) + '00000000'
+
+        if token_out_address == self.weth_token:
+            encoded_action = self.contract.encode_abi("unwrapWETH9", args=(amount_out_min_in, account.address))
+        else:
+            encoded_action = self.contract.encode_abi("refundETH") + pad_hex(account.address, 128)
+
+        return self.contract.functions.multicall([eth_to_usdc, encoded_action]).build_transaction(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/mendi_finance_contract.py

@@ -0,0 +1,11 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.data.networks import get_ids_chain
+from sybil_engine.data.tokens import get_tokens_for_chain
+
+abi = 'test'
+
+
+class MendiFinanceContract(Contract):
+    def __init__(self, contract_address, web3):
+        self.weth_token = get_tokens_for_chain(get_ids_chain()[web3.eth.chain_id])['WETH']
+        super().__init__(contract_address, web3, abi)

web3_wizzard_lib/core/contract/mendi_token.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/mendi_token.json")
+
+
+class MendiTokenContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(self, account, amount):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.mint(amount).build_transaction(txn_params)
+
+    @evm_transaction
+    def redeem(self, account, amount):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.redeemUnderlying(amount).build_transaction(txn_params)
+
+    def balance_of(self, account):
+        return self.contract.functions.balanceOfUnderlying(account.address).call()

web3_wizzard_lib/core/contract/merkly_minter.py

@@ -0,0 +1,47 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction, l0_evm_transaction
+from sybil_engine.utils.file_loader import load_abi
+from web3 import Web3
+
+abi = load_abi("resources/abi/merkly.json")
+
+
+class MerklyMinter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = Web3.to_wei(0.0004, "ether")
+        contract_txn = self.contract.functions.mint().build_transaction(txn_params)
+
+        return contract_txn
+
+    @l0_evm_transaction
+    def refuel(self, account, to_chain_id, amount_wei, fee):
+        txn_params = self.build_generic_data(account.address, False)
+
+        hex_amount = self.decimal_to_hex_padded(amount_wei)
+
+        txn_params['value'] = amount_wei + fee
+        contract_txn = self.contract.functions.bridgeGas(
+            to_chain_id,
+            account.address,
+            f'0x00020000000000000000000000000000000000000000000000000000000000030d4000000000000000000000000000000000{hex_amount}{account.address[2:]}'
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    def estimate_send_fee(self, account, to_chain_id, hex_amount):
+        return self.contract.functions.estimateSendFee(
+            to_chain_id,
+            b'0x',  # _zroPaymentAddress
+            f'0x00020000000000000000000000000000000000000000000000000000000000030d4000000000000000000000000000000000{hex_amount}{account.address[2:]}'
+            # _adapterParams
+        ).call()[0]
+
+    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/micro3_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/micro3.json")
+
+
+class Micro3Contract(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, False)
+
+        txn_params['value'] = 80000000000000
+
+        return self.contract.functions.purchase(amount).build_transaction(txn_params)

web3_wizzard_lib/core/contract/mute_router.py

@@ -0,0 +1,93 @@
+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/mute_router.json")
+
+
+class MuteRouter(Contract):
+    def __init__(self, contract_address, web3):
+        tokens = get_tokens_for_chain(get_ids_chain()[web3.eth.chain_id])
+        self.weth_address = tokens['WETH']
+        self.usdc_address = tokens['USDC']
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def swap_exact_eth_for_tokens_supporting_fee_on_transfer_tokens(self, account, amount_to_swap, token_in_address,
+                                                                    token_out_address, amount_out_min):
+        sender = account.address
+
+        path = [token_in_address, token_out_address]
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        stable = [True, False] if token_out_address == self.usdc_address else [False, False]
+
+        txn_params = self.build_generic_data(sender)
+
+        txn_params['value'] = amount_to_swap.wei
+        txn_params['data'] = self.contract.encode_abi('swapExactETHForTokensSupportingFeeOnTransferTokens', args=(
+            amount_out_min,
+            path,
+            sender,
+            deadline,
+            stable
+        )
+                                                     )
+
+        txn_params['gas'] = self.web3.eth.estimate_gas(txn_params)
+
+        return txn_params
+
+    @evm_transaction
+    def swap_exact_tokens_for_eth_supporting_fee_on_transfer_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, False)
+
+        path = [token_in_address, token_out_address]
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        stable = [False, False]
+
+        contract_txn = self.contract.functions.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            amount_to_swap.wei,
+            amount_out_min,
+            path,
+            sender,
+            deadline,
+            stable
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    @evm_transaction
+    def swap_exact_tokens_for_tokens_supporting_fee_on_transfer_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, False)
+
+        path = [token_in_address, self.weth_address, token_out_address]
+        deadline = int(datetime.now().timestamp() + 60 * 60 * 3)
+        stable = [True, False, False] if token_in_address == self.usdc_address else [False, True, False]
+
+        contract_txn = self.contract.functions.swapExactTokensForTokensSupportingFeeOnTransferTokens(
+            amount_to_swap.wei,
+            amount_out_min,
+            path,
+            sender,
+            deadline,
+            stable
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    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/new_rage_contract.py

@@ -0,0 +1,31 @@
+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/new_rage_abi.json")
+
+
+class NewRageContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def redeem(self, account, shares):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.redeem(
+            shares,
+            account.address,
+            account.address,
+        ).build_transaction(txn_params)
+
+        return contract_txn
+
+    def balance_of(self, account):
+        return self.contract.functions.balanceOf(account.address).call()
+
+    def convert_to_shares(self, amount):
+        return self.contract.functions.convertToShares(amount).call()
+
+    def max_redeem(self, account):
+        return self.contract.functions.maxRedeem(account.address).call()

web3_wizzard_lib/core/contract/nidum_contract.py

@@ -0,0 +1,44 @@
+from loguru import logger
+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/nidus.json")
+
+
+class NidumContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint_nft(self, account, claim_data):
+        txn_params = self.build_generic_data(account.address, False)
+
+        token_ids = [9]
+        nft_amounts = [1]
+        nonce = 0
+
+        message = claim_data['message']
+        signature = claim_data['signature']
+
+        return self.contract.functions.mintFromShadowBatch(
+            _tokenID=token_ids,
+            _nftAmountForMint=nft_amounts,
+            _nonce=nonce,
+            _msgForSign=message,  # The original hashed message (no changes needed here)
+            _signature=signature  # The generated signature
+        ).build_transaction(txn_params)
+
+    @evm_transaction
+    def burn(self, account):
+        txn_params = self.build_generic_data(account.address, False)
+        token_id = 9
+
+        balance = self.contract.functions.balanceOf(account.address, token_id).call()
+        if balance == 0:
+            logger.error(f"[{account.app_id}][{account.address}] No nidum nft. Mint first. Skip module")
+            return
+
+        return self.contract.functions.burn(
+            self.contract.address, 9, 1
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/nile_contract.py

@@ -0,0 +1,60 @@
+import random
+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
+from web3 import Web3
+
+abi = load_abi("resources/abi/nile_pool.json")
+
+
+class NileContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def add_liquidity_eth(self, account, token, max_token, amount_eth):
+        tx_data = self.build_generic_data(account.address, False)
+
+        deadline = int(datetime.now().timestamp()) + random.randint(60, 60 * 60 * 24)
+        tx_data['value'] = amount_eth.wei
+
+        return self.contract.functions.addLiquidityETH(
+            token,
+            False,
+            int(max_token * 0.99),
+            int(max_token * 0.95),
+            int(amount_eth.wei * 0.95),
+            account.address,
+            deadline
+        ).build_transaction(tx_data)
+
+    @evm_transaction
+    def remove_liquidity_eth(self, account, token, liquidity, amount_eth, max_token):
+        tx_data = self.build_generic_data(
+            account.address,
+            False
+        )
+
+        deadline = int(datetime.now().timestamp()) + random.randint(60, 60 * 60 * 24)
+
+        return self.contract.functions.removeLiquidityETH(
+            token,
+            False,
+            int(liquidity * 0.99),
+            int(max_token * 0.95),
+            int(amount_eth * 0.95),
+            account.address,
+            deadline
+        ).build_transaction(tx_data)
+
+    def quote_remove_liquidity_eth(self, token_in, token_out, liquidity):
+        return self.contract.functions.quoteRemoveLiquidity(token_in, token_out, False, liquidity).call()
+
+    def get_amount_out(self, amount, from_token, to_token):
+        return self.contract.functions.getAmountOut(
+            amount.wei,
+            Web3.to_checksum_address(from_token),
+            Web3.to_checksum_address(to_token)
+        ).call()

web3_wizzard_lib/core/contract/nomis_attest_contract.py

@@ -0,0 +1,40 @@
+from loguru import logger
+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/nomis_attest.json")
+
+
+class NomisAttestContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def attest(self,
+               account,
+               schema,
+               expirationTime,
+               revocable,
+               tokenId,
+               updated,
+               value,
+               chainId,
+               calcModel,
+               validationPayload
+        ):
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['gasPrice'] = int(self.web3.eth.gas_price * 2)
+        return self.contract.functions.attestNomisScoreSimple(
+            schema,
+            expirationTime,
+            revocable,
+            tokenId,
+            updated,
+            value,
+            chainId,
+            calcModel,
+            validationPayload
+        ).build_transaction(txn_params)
+

web3_wizzard_lib/core/contract/nomis_contract.py

@@ -0,0 +1,40 @@
+from loguru import logger
+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/nomis.json")
+
+
+class NomisContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def set_score(self,
+                  account,
+                  signature,
+                  mintedScore,
+                  calculationModel,
+                  deadline,
+                  metadataUrl,
+                  chainId,
+                  referralCode,
+                  referrerCode,
+                  onftMetadataUrl
+                  ):
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['value'] = Web3.to_wei(0.001, 'ether')
+        return self.contract.functions.setScore(
+            signature,
+            mintedScore,
+            calculationModel,
+            deadline,
+            metadataUrl,
+            chainId,
+            referralCode,
+            referrerCode,
+            onftMetadataUrl
+        ).build_transaction(txn_params)
+

web3_wizzard_lib/core/contract/octomos.py

@@ -0,0 +1,31 @@
+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/octomos.json")
+
+
+class OctomosContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def launchpadBuy(self,
+                     account,
+                     undef,
+                     launchpadId,
+                     slotId,
+                     quantity,
+                     additional,
+                     data
+                     ):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.launchpadBuy(
+            undef,
+            launchpadId,
+            slotId,
+            quantity,
+            additional,
+            data
+        ).build_transaction(txn_params)

web3_wizzard_lib/core/contract/odos.py

@@ -0,0 +1,104 @@
+import requests
+from sybil_engine.config.app_config import get_network
+
+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 sybil_engine.utils.utils import SwapException
+
+abi = load_abi("resources/abi/lineaswap_router.json")
+
+referral = {
+    324: 387663447,
+    260: 387663447,
+    8453: 1030612943,
+    18453: 1030612943,
+    59144: 268273819
+}
+
+chain_map_id = {
+    'BASE': 8453,
+    'ZKSYNC': 324
+}
+
+
+class Odos(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def quote(self, account, from_token: str, to_token: str, amount: int, slippage: float, chain: str):
+        chain_id = self.get_chain_id(chain)
+
+        url = "https://api.odos.xyz/sor/quote/v2"
+
+        data = {
+            "chainId": chain_id,
+            "inputTokens": [
+                {
+                    "tokenAddress": from_token,
+                    "amount": f"{amount}"
+                }
+            ],
+            "outputTokens": [
+                {
+                    "tokenAddress": to_token,
+                    "proportion": 1
+                }
+            ],
+            "slippageLimitPercent": slippage,
+            "userAddr": account.address,
+            "referralCode": referral[self.web3.eth.chain_id] if True is True else 0,
+            "compact": True
+        }
+
+        response = self.proxy_request(account, data, url)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise SwapException(f"[{account.app_id}][{account.address}] Bad Odos request")
+
+    def assemble(self, account, path_id):
+        url = "https://api.odos.xyz/sor/assemble"
+
+        data = {
+            "userAddr": account.address,
+            "pathId": path_id,
+            "simulate": False,
+        }
+
+        response = self.proxy_request(account, data, url)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise SwapException(f"[{account.app_id}][{account.address}] Bad Odos request")
+
+    def proxy_request(self, account, data, url):
+        proxies = {}
+        proxies.update(
+            {"http": account.proxy}
+        )
+        response = requests.post(
+            url=url,
+            headers={"Content-Type": "application/json"},
+            json=data,
+            proxies=proxies
+        )
+        return response
+
+    @evm_transaction
+    def swap(self, account, transaction_data):
+        transaction = transaction_data["transaction"]
+
+        transaction["nonce"] = self.web3.eth.get_transaction_count(transaction['from'])
+        transaction["chainId"] = self.web3.eth.chain_id
+        transaction["value"] = int(transaction["value"])
+
+        return transaction
+
+    def get_chain_id(self, chain):
+        if get_network() == 'MAIN':
+            return self.web3.eth.chain_id
+        else:
+            return chain_map_id[chain]

web3_wizzard_lib/core/contract/omnisea.py

@@ -0,0 +1,29 @@
+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
+
+abi = load_abi("resources/abi/omnisea.json")
+
+
+class OmniSea(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def create(self, account, title, symbol):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.create([
+            title,
+            symbol,
+            "",
+            "",
+            0,
+            True,
+            0,
+            int(time.time()) + 1000000]
+        ).build_transaction(txn_params)
+
+        return contract_txn

web3_wizzard_lib/core/contract/orbiter_starknet.py

@@ -0,0 +1,30 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_starknet_transaction
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/orbiter_starknet.json")
+
+
+class OrbiterStarknet(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_starknet_transaction
+    def bridge(self, account, amount):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = amount.wei
+
+        if account.starknet_address[:3] == '0x0':
+            starknet_wallet = f'030{account.starknet_address[3:]}'
+        else:
+            starknet_wallet = f'030{account.starknet_address[2:]}'
+
+        starknet_wallet = bytes.fromhex(starknet_wallet)
+
+        contract_txn = self.contract.functions.transfer(
+            '0x80C67432656d59144cEFf962E8fAF8926599bCF8',
+            starknet_wallet
+        ).build_transaction(txn_params)
+
+        return contract_txn