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

core/contract/pancake_router.py

@@ -0,0 +1,72 @@
+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_wizzard_lib.core.modules import NativeBalance, Erc20Balance
+
+abi = load_abi("resources/abi/pancake/router.json")
+
+
+class PancakeRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def swap_to_token(self, account, amount: NativeBalance, from_token: str, to_token: str, min_amount_out: int):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = amount.wei
+
+        deadline = int(time.time()) + 1000000
+
+        transaction_data = self.contract.encode_abi(
+            "exactInputSingle",
+            args=[(
+                from_token,
+                to_token,
+                500,
+                account.address,
+                amount.wei,
+                min_amount_out,
+                0
+            )]
+        )
+
+        return self.contract.functions.multicall(deadline, [transaction_data]).build_transaction(txn_params)
+
+    @evm_transaction
+    def swap_to_eth(self, account, amount: Erc20Balance, from_token: str, to_token: str, min_amount_out: int):
+        txn_params = self.build_generic_data(account.address, False)
+
+        deadline = int(time.time()) + 1000000
+
+        transaction_data = self.contract.encode_abi(
+            fn_name="exactInputSingle",
+            args=[(
+                from_token,
+                to_token,
+                500,
+                "0x0000000000000000000000000000000000000002",
+                amount.wei,
+                min_amount_out,
+                0
+            )]
+        )
+
+        unwrap_data = self.contract.encode_abi(
+            fn_name="unwrapWETH9",
+            args=[
+                min_amount_out,
+                account.address
+            ]
+
+        )
+
+        contract_txn = self.contract.functions.multicall(
+            deadline,
+            [transaction_data, unwrap_data]
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/rage_claim.py

@@ -0,0 +1,24 @@
+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/rage_claim.json")
+
+
+class RageClaimer(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def claim(self, account, amount, index, merkle_proof):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.claim(
+            index,
+            account.address,
+            amount,
+            merkle_proof
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/reactor_fusion_contract.py

@@ -0,0 +1,78 @@
+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/reactor_fusion.json")
+
+
+class ReactorFusionContract(Contract):
+
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def get_deposit_amount(self, account):
+        return self.contract.functions.balanceOf(account.address).call()
+
+    @evm_transaction
+    def mint(self, account, amount_wei: int):
+        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))
+        tx_data['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.redeem(amount).build_transaction(tx_data)
+
+        # if amount > 0:
+        #     logger.info(
+        #         f"[{self.account_id}][{self.address}] Make withdraw from ReactorFusion | " +
+        #         f"{Web3.from_wei(amount, 'ether')} ETH"
+        #     )
+        #
+        #
+        # else:
+        #     logger.error(f"[{self.account_id}][{self.address}] Deposit not found")
+
+    # @retry
+    # @check_gas
+    # async def enable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Enable collateral on ReactorFusion")
+    #
+    #     contract = self.get_contract(REACTORFUSION_CONTRACTS["collateral"], REACTORFUSION_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #
+    #     transaction = await contract.functions.enterMarkets(
+    #         [Web3.to_checksum_address(REACTORFUSION_CONTRACTS["landing"])]
+    #     ).build_transaction(tx_data)
+    #
+    #     signed_txn = await self.sign(transaction)
+    #
+    #     txn_hash = await self.send_raw_transaction(signed_txn)
+    #
+    #     await self.wait_until_tx_finished(txn_hash.hex())
+    #
+    # @retry
+    # @check_gas
+    # async def disable_collateral(self):
+    #     logger.info(f"[{self.account_id}][{self.address}] Disable collateral on ReactorFusion")
+    #
+    #     contract = self.get_contract(REACTORFUSION_CONTRACTS["collateral"], REACTORFUSION_ABI)
+    #
+    #     tx_data = await self.get_tx_data()
+    #
+    #     transaction = await contract.functions.exitMarket(
+    #         Web3.to_checksum_address(REACTORFUSION_CONTRACTS["landing"])
+    #     ).build_transaction(tx_data)
+    #
+    #     signed_txn = await self.sign(transaction)
+    #
+    #     txn_hash = await self.send_raw_transaction(signed_txn)
+    #
+    #     await self.wait_until_tx_finished(txn_hash.hex())

core/contract/readon_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
+
+abi = load_abi("resources/abi/abbysworld.json")
+
+
+class ReadOnContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def curate(self, account, contentUrl):
+        txn_params = self.build_generic_data(account.address, True)
+
+        txn_params['data'] = f'0x7859bb8d{contentUrl}'
+        txn_params['gasPrice'] = self.web3.eth.gas_price
+
+        return txn_params

core/contract/rubyscore_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
+from web3 import Web3
+
+abi = load_abi("resources/abi/rubyscore.json")
+
+
+class RubyscoreContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def attest_rubyscore(self, account, signature, schemaId, expirationDate):
+        txn_params = self.build_generic_data(account.address, False)
+
+        txn_params['value'] = 500000000000000
+
+        signature_bytes = Web3.to_bytes(hexstr=signature[2:])
+
+        contract_txn = self.contract.functions.attestRubyscore(
+            (
+                Web3.to_bytes(hexstr=schemaId[2:]),
+                expirationDate,
+                Web3.to_bytes(hexstr=f'000000000000000000000000{account.address[2:]}'),
+                Web3.to_bytes(hexstr='0000000000000000000000000000000000000000000000000000000000000000'),
+            ),
+            [signature_bytes]  # Encapsulate in a list to match bytes[]
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/satoshi_universe_contract.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/satoshi_universe.json")
+
+
+class SatoshiUniverseContract(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)
+
+        txn_params['value'] = 150000000000000
+
+        contract_txn = self.contract.functions.mint(
+            (
+                account.address,
+                '0xFf9B136F19D1Ad1f1716e2Ebe98b4A773f263275',
+                amount,
+                [],
+                1,
+                '0x'
+            )
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/scroll_bridge_contract.py

@@ -0,0 +1,24 @@
+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/scroll_bridge.json")
+
+
+class ScrollBridgeContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def withdraw(
+            self,
+            account,
+            amount_wei
+    ):
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['value'] = amount_wei
+
+        return self.contract.functions.withdrawETH(
+            amount_wei,
+            0
+        ).build_transaction(txn_params)

core/contract/scroll_canvas_mint_contract.py

@@ -0,0 +1,26 @@
+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/scroll_canvas_mint.json")
+
+
+class ScrollCanvasMintContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def mint(
+            self,
+            account,
+            username,
+            referral,
+            value
+    ):
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['value'] = value
+
+        return self.contract.functions.mint(
+            username,
+            referral
+        ).build_transaction(txn_params)

core/contract/scroll_oracle.py

@@ -0,0 +1,11 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.utils.file_loader import load_abi
+
+abi = load_abi("resources/abi/scroll_oracle.json")
+
+class ScrollOracle(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def estimateCrossDomainMessageFee(self):
+        return self.contract.functions.estimateCrossDomainMessageFee(168000).call()

core/contract/snap_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/snap.json")
+
+
+class SnapContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def stake(self, account, token_id):
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.stake(token_id).build_transaction(txn_params)

core/contract/social_scan_contract.py

@@ -0,0 +1,20 @@
+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/socialscan.json")
+
+
+class SocialScanContract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def set_approval_for_all(self, account, operator, approved):
+        txn_params = self.build_generic_data(account.address, False)
+
+        contract_txn = self.contract.functions.setApprovalForAll(
+            operator, approved
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/stargate_farming.py

@@ -0,0 +1,37 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+
+with open("resources/abi/stargate_farming.json") as f:
+    abi = f.read()
+
+
+class StargateFarming(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def deposit(self, account, pool_amount):
+        sender = account.address
+        txn_params = self.build_generic_data(sender, False)
+
+        contract_txn = self.contract.functions.deposit(0, pool_amount.wei).build_transaction(txn_params)
+        contract_txn['gas'] = int(self.web3.eth.estimate_gas(contract_txn) * 1.05)
+
+        return contract_txn
+
+    @evm_transaction
+    def withdraw(self, account, amount_to_bridge):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, False)
+
+        contract_txn = self.contract.functions.withdraw(
+            0,
+            amount_to_bridge
+        ).build_transaction(txn_params)
+        contract_txn['gas'] = int(self.web3.eth.estimate_gas(contract_txn) * 1.05)
+
+        return contract_txn
+
+    def user_info(self, account):
+        return int(self.contract.functions.userInfo(0, account.address).call()[0])

core/contract/stargate_router.py

@@ -0,0 +1,84 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction, l0_evm_transaction
+
+from web3_wizzard_lib.core.modules.stargate.stargate_gas_checker import stargate_check_gas
+
+with open("resources/abi/stargate_router.json") as f:
+    abi = f.read()
+
+
+class StargateRouter(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def add_liquidity(self, account, pool_amount):
+        from_address = account.address
+
+        txn_params = self.build_generic_data(from_address, False)
+
+        contract_txn = self.contract.functions.addLiquidity(
+            self.chain_instance['stargate_usdc_pool'],
+            pool_amount.wei,
+            from_address
+        ).build_transaction(txn_params)
+
+        contract_txn['gas'] = (self.web3.eth.estimate_gas(contract_txn) * 1.1)
+
+        return contract_txn
+
+    @evm_transaction
+    def instant_redeem(self, account, amount_to_bridge, stargate_pool_id):
+        from_address = account.address
+
+        txn_params = self.build_generic_data(from_address, False)
+
+        contract_txn = self.contract.functions.instantRedeemLocal(
+            stargate_pool_id,
+            amount_to_bridge,
+            from_address
+        ).build_transaction(txn_params)
+        contract_txn['gas'] = int(self.web3.eth.estimate_gas(contract_txn) * 1.1)
+
+        return contract_txn
+
+    @stargate_check_gas("USDC")
+    @l0_evm_transaction
+    def swap(self, account, value_fee, amount_to_bridge, to_chain_instance):
+        from_address = account.address
+
+        txn_params = self.build_generic_data(from_address, False)
+        txn_params['value'] = value_fee
+
+        lz_tx_obj = [0, 0, '0x0000000000000000000000000000000000000001']
+
+        if amount_to_bridge.token == 'USDC':
+            stargate_pool = to_chain_instance['stargate_usdc_pool']
+        else:
+            stargate_pool = to_chain_instance['stargate_eth_pool']
+
+        contract_txn = self.contract.functions.swap(
+            to_chain_instance['stargate_chain_id'],
+            stargate_pool,
+            stargate_pool,
+            from_address,
+            amount_to_bridge.wei,
+            int(amount_to_bridge.wei * 0.985),
+            lz_tx_obj,
+            from_address,
+            '0x'
+        ).build_transaction(txn_params)
+        contract_txn['gas'] = int(self.web3.eth.estimate_gas(contract_txn) * 1.1)
+
+        return contract_txn
+
+    def count_native_fee_stargate(self, chain_id, address):
+        return int(
+            self.contract.functions.quoteLayerZeroFee(
+                chain_id,
+                1,
+                address,
+                '0x',
+                (0, 0, address)
+            ).call()[0] * 1.1
+        )

core/contract/stargate_router_eth.py

@@ -0,0 +1,41 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction, l0_evm_transaction
+
+from web3_wizzard_lib.core.modules.stargate.stargate_gas_checker import stargate_check_gas
+
+with open("resources/abi/stargate_swapETH_abi.json") as f:
+    abi = f.read()
+
+
+class StargateRouterEth(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def add_liquidity_eth(self, account, pool_amount):
+        from_address = account.address
+
+        txn_params = self.build_generic_data(from_address, False)
+        txn_params['value'] = pool_amount.wei
+
+        contract_txn = self.contract.functions.addLiquidityETH().build_transaction(txn_params)
+
+        return contract_txn
+
+    @stargate_check_gas(token='ETH')
+    @l0_evm_transaction
+    def swap_eth(self, account, value_wei, amount_to_bridge_wei, to_chain_instance):
+        from_address = account.address
+
+        txn_params = self.build_generic_data(account.address, False)
+        txn_params['value'] = value_wei
+
+        contract_txn = self.contract.functions.swapETH(
+            to_chain_instance['stargate_chain_id'],
+            from_address,
+            from_address,
+            amount_to_bridge_wei,
+            int(amount_to_bridge_wei * 0.985)
+        ).build_transaction(txn_params)
+
+        return contract_txn

core/contract/stargate_token_pool.py

@@ -0,0 +1,46 @@
+from loguru import logger
+from sybil_engine.contract.contract import Contract
+from web3 import Web3
+
+with open("resources/abi/stargate_token_pool.json") as f:
+    abi = f.read()
+
+
+MAX_ALLOWANCE = 115792089237316195423570985008687907853269984665640564039457584007913129639935
+
+
+class StargateTokenPool(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    def approve_pool(self, account, contract_on_approve):
+        logger.info(f"Approving token for pool")
+
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+
+        contract_txn = self.contract.functions.approve(
+            Web3.to_checksum_address(contract_on_approve),
+            MAX_ALLOWANCE
+        ).build_transaction(txn_params)
+
+        contract_txn['gas'] = int(self.web3.eth.estimate_gas(contract_txn) * 1.1)
+
+        return contract_txn
+
+    def balance_of(self, account):
+        return self.contract.functions.balanceOf(account.address).call()
+
+    def approve(self, account, contract_on_approve):
+        logger.info(f"Approving token")
+
+        txn_params = self.build_generic_data(account.address, False)
+
+        return self.contract.functions.approve(
+            Web3.to_checksum_address(contract_on_approve),
+            MAX_ALLOWANCE
+        ).build_transaction(txn_params)
+
+    def allowance(self, account, allowance_contract):
+        return self.contract.functions.allowance(account.address, Web3.to_checksum_address(allowance_contract)).call()

core/contract/stargate_v2_contract.py

@@ -0,0 +1,36 @@
+from sybil_engine.contract.contract import Contract
+from sybil_engine.contract.transaction_executor import evm_transaction
+
+with open("resources/abi/stargate_v2.json") as f:
+    abi = f.read()
+
+
+class StargateV2Contract(Contract):
+    def __init__(self, contract_address, web3):
+        super().__init__(contract_address, web3, abi)
+
+    @evm_transaction
+    def send(
+            self,
+            account,
+            value,
+            send_params,
+            stargate_fee,
+            refund_address
+    ):
+        sender = account.address
+
+        txn_params = self.build_generic_data(sender, set_contract_address=False)
+        txn_params['value'] = value
+
+        return self.contract.functions.send(
+            send_params,
+            stargate_fee,
+            refund_address
+        ).build_transaction(txn_params)
+
+    def quote_send(self, send_params):
+        return self.contract.functions.quoteSend(
+            send_params,
+            False
+        ).call()

core/contract/syncswap_classic_pool.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.json")
+
+
+class SyncSwapClassicPool(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()

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()

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()