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

web3_wizzard_lib/core/modules/nft/lucky_cat.py

@@ -1,25 +0,0 @@
-from sybil_engine.contract.send import Send
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class LuckyCat(SubModule):
-    module_name = 'LUCKYCAT'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['LUCKYCAT']
-
-        send = Send(None, web3)
-        send.send_to_wallet(
-            account, contract_address, NativeBalance(0, chain, "ETH"), "0x70245bdc"
-        )
-
-    def log(self):
-        return "LUCKYCAT"

web3_wizzard_lib/core/modules/nft/merkly_minter_module.py

@@ -1,22 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.merkly_minter import MerklyMinter
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class MerklyMinterModule(SubModule):
-    module_name = "MERKLY_MINTER"
-
-    def execute(self, account, chain='ZKSYNC'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['MERKLY']
-        merkly_minter = MerklyMinter(contract_address, web3)
-
-        merkly_minter.mint(account)
-
-    def log(self):
-        return "MERKLY MINTER"

web3_wizzard_lib/core/modules/nft/micro3.py

@@ -1,23 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.micro3_contract import Micro3Contract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Micro3(SubModule):
-    module_name = 'MICRO3'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['MICRO3']
-
-        micro3_cotnract = Micro3Contract(contract_address, web3)
-
-        micro3_cotnract.purchase(account, 1)
-
-    def log(self):
-        return "MICRO3 NFT"

web3_wizzard_lib/core/modules/nft/mint_2048.py

@@ -1,28 +0,0 @@
-import secrets
-
-from sybil_engine.contract.send import Send
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Mint2048(SubModule):
-    module_name = '2048'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['2048']
-
-        data = f'0x36ab86c4{secrets.token_hex(32)}0000000000000000000000000000000000000000000000000000000000000001'
-        send = Send(None, web3)
-        send.send_to_wallet(
-            account, contract_address, NativeBalance(0, chain, "ETH"), data
-        )
-
-    def log(self):
-        return "2048 NFT"

web3_wizzard_lib/core/modules/nft/nft_submodule.py

@@ -1,16 +0,0 @@
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class NftSubmodule(SubModule):
-    def execute(self, *args):
-        pass
-
-    def log(self):
-        pass
-
-    def create_web3(self, account, chain):
-        chain_instance = get_chain_instance(chain)
-        return init_web3(chain_instance, account.proxy)

web3_wizzard_lib/core/modules/nft/nidum.py

@@ -1,87 +0,0 @@
-from json import dumps
-
-import requests
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.nidum_contract import NidumContract
-from web3_wizzard_lib.core.modules.nft.sign import sign_msg
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Nidum(SubModule):
-    module_name = 'NIDUM'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['NIDUM']
-        nidus_nft = NidumContract(contract_address, web3)
-
-        claim_data = request_ops(account, web3)
-
-        nidus_nft.mint_nft(account, claim_data)
-
-    def log(self):
-        return "NIDUM NFT"
-
-
-def register_wallet(wallet):
-    url = f'https://auth.sidusheroes.com/api/v1/users'
-    headers = {'Content-Type': 'application/json'}
-    data = {'address': wallet.address.lower()}
-    json_data = dumps(data)
-    requests.post(url, data=json_data, headers=headers)
-
-
-def get_msg(wallet):
-    url = 'https://auth.sidusheroes.com/api/v1/users/' + wallet.address.lower()
-    r = requests.get(url)
-    response = r.json()
-    nonce = response['data']['nonce']
-    msg_text = f'Please sign this message to connect to sidusheroes.com: {nonce}'
-    return msg_text
-
-
-def auth(wallet, signature):
-    data = {"address": f"{wallet.address}", "signature": f"{signature}"}
-    json_data = dumps(data)
-    url = 'https://auth.sidusheroes.com/api/v1/auth'
-    headers = {'Content-Type': 'application/json'}
-    r = requests.post(url, data=json_data, headers=headers)
-    response = r.json()
-    bearer = response['data']['accessToken']
-    return bearer
-
-
-def get_token_data(wallet, bearer):
-    url = f'https://plsrv.sidusheroes.com/shadow-game-linea/api/v1/item'
-    headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {bearer}'}
-    data = {"user": f"{wallet.address.lower()}", "contract": "0x34Be5b8C30eE4fDe069DC878989686aBE9884470", "tokenId": 9}
-    json_data = dumps(data)
-    r = requests.post(url, data=json_data, headers=headers)
-
-
-def get_claim_data(wallet, bearer):
-    url = 'https://plsrv.sidusheroes.com/shadow-game-linea/api/v1/claim'
-    headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {bearer}',
-               'Content-Length': '151', 'If-None-Match': 'W/"81-IPXBWNB48bs1CNK6NL+XgeHJooA"'}
-    data = {"contract": "0x34Be5b8C30eE4fDe069DC878989686aBE9884470",
-            "user": f'{wallet.address.lower()}',
-            "tokensData": [{"tokenId": 9, "amount": 1}]}
-    json_data = dumps(data)
-    r = requests.post(url, data=json_data, headers=headers)
-    response = r.json()
-    return response
-
-
-def request_ops(wallet, web3):
-    register_wallet(wallet)
-    msg_text = get_msg(wallet)
-    signature = sign_msg(wallet, msg_text, web3)
-    bearer = auth(wallet, signature)
-    get_token_data(wallet, bearer)
-    claim_data = get_claim_data(wallet, bearer)
-    return claim_data

web3_wizzard_lib/core/modules/nft/nidum_bonus.py

@@ -1,23 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.nidum_contract import NidumContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class NidumBonus(SubModule):
-    module_name = 'NIDUM_BONUS'
-    allow_reuse_address = True
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['NIDUM']
-        nidum_nft = NidumContract(contract_address, web3)
-
-        nidum_nft.burn(account)
-
-    def log(self):
-        return "NIDUM BONUS NFT"

web3_wizzard_lib/core/modules/nft/nomis.py

@@ -1,64 +0,0 @@
-import requests
-from loguru import logger
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.nomis_contract import NomisContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Nomis(SubModule):
-    module_name = 'NOMIS'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['NOMIS']
-
-        response = requests.get(f'https://bg.nomis.cc/api/proxy/linea/wallet/{account.address}/score?scoreType=0&calculationModel=14&UseTokenLists=false&nonce=0&deadline=1790647549&GetCyberConnectProtocolData=false&prepareToMint=true&MintChain=0&ShouldGetReferrerCode=false&disableProxy=true&referrerCode=nomis', timeout=10)
-
-        signature = response.json()['data']['mintData']['signature']
-        mintedScore = response.json()['data']['mintData']['mintedScore']
-        deadline = response.json()['data']['mintData']['deadline']
-        metadataUrl = response.json()['data']['mintData']['metadataUrl']
-        chainId = response.json()['data']['mintData']['chainId']
-        referralCode = response.json()['data']['mintData']['referralCode']
-        referrerCode = response.json()['data']['mintData']['referrerCode']
-        calculationModel = response.json()['data']['mintData']['calculationModel']
-        onftMetadataUrl = response.json()['data']['mintData']['onftMetadataUrl']
-
-        nomis_contract = NomisContract(contract_address, web3)
-
-        if mintedScore < 3000:
-            formatted_score = "{:.2f}".format(mintedScore / 100)
-            logger.info(f"Minted score is  {formatted_score}, minimum 30 is required, skip account")
-            return
-
-        nomis_contract.set_score(
-            account,
-            signature,
-            mintedScore,
-            calculationModel,
-            deadline,
-            metadataUrl,
-            chainId,
-            referralCode,
-            referrerCode,
-            onftMetadataUrl
-        )
-
-    def log(self):
-        return "NOMIS POH"
-
-
-def get_attest_data_media(token_auth):
-    url = 'https://mp.trustalabs.ai/accounts/attest_calldata?attest_type=media'
-    headers = {'Authorization': f'TOKEN {token_auth}', 'Accept': 'application/json'}
-    r = requests.get(url, headers=headers)
-    if r.status_code == 200:
-        res = [r.json()]
-        if res[0]['code'] == 0:
-            txn_calldata = res[0]['data']
-            return txn_calldata

web3_wizzard_lib/core/modules/nft/nomis_attest.py

@@ -1,66 +0,0 @@
-import requests
-from loguru import logger
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.retry import retry
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.nomis_attest_contract import NomisAttestContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class NomisAttest(SubModule):
-    module_name = 'NOMIS_ATTEST'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['NOMIS_ATTEST']
-
-        url_template = f'http://nomis.cc/api/proxy/verax/attestation-data?address={account.address}&nonce=0'
-
-        response = self.get_attest(url_template)
-
-        mintedScore = response['data']['value']
-
-        if mintedScore < 3000:
-            formatted_score = "{:.2f}".format(mintedScore / 100)
-            logger.info(f"Minted score is  {formatted_score}, minimum 30 is required, skip account")
-            return
-
-        schema = response['data']['schema']
-        expirationTime = response['data']['expirationTime']
-        revocable = response['data']['revocable']
-        tokenId = response['data']['tokenId']
-        updated = response['data']['updated']
-        value = response['data']['value']
-        chainId = response['data']['chainId']
-        calcModel = response['data']['calcModel']
-        validationPayload = response['data']['validationPayload']
-
-        nomis_attest_contract = NomisAttestContract(contract_address, web3)
-
-        nomis_attest_contract.attest(
-            account,
-            schema,
-            expirationTime,
-            revocable,
-            tokenId,
-            updated,
-            value,
-            chainId,
-            calcModel,
-            validationPayload
-        )
-
-    @retry(max_attempts=15, retry_interval={'from': 60 * 1, 'to': 60 * 4})
-    def get_attest(self, url_template):
-        response = requests.get(url_template)
-        if response.status_code == 200:
-            return response.json()
-        else:
-            raise Exception(f"HTTP error {response.json()}")
-
-    def log(self):
-        return "ATTEST NOMIS SCORE"

web3_wizzard_lib/core/modules/nft/nouns.py

@@ -1,27 +0,0 @@
-from sybil_engine.contract.send import Send
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Nouns(SubModule):
-    module_name = 'NOUNS'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['NOUNS']
-
-        data = f'0x57bc3d78000000000000000000000000{account.address[2:]}00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000080ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
-
-        send = Send(None, web3)
-        send.send_to_wallet(
-            account, contract_address, NativeBalance(0, chain, "ETH"), data
-        )
-
-    def log(self):
-        return "NOUNS NFT"

web3_wizzard_lib/core/modules/nft/octomos.py

@@ -1,32 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-from web3 import Web3
-
-from web3_wizzard_lib.core.contract.octomos import OctomosContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Octomos(SubModule):
-    module_name = 'OCTOMOS'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['OCTOMOS']
-
-        octomos_contract = OctomosContract(contract_address, web3)
-
-        octomos_contract.launchpadBuy(
-            account,
-            Web3.to_bytes(hexstr='0x0c21cfbb').ljust(4, b'\0'),
-            Web3.to_bytes(hexstr='0x53b93973').ljust(4, b'\0'),
-            0,
-            1,
-            [],
-            b''
-        )
-
-    def log(self):
-        return "OCTOMOS"

web3_wizzard_lib/core/modules/nft/omnisea.py

@@ -1,33 +0,0 @@
-import random
-
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.omnisea import OmniSea
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class OmniSeaModule(SubModule):
-    module_name = 'OMNI_SEA'
-
-    def execute(self, account, chain='ZKSYNC'):
-
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['OMNISEA']
-        omnisea = OmniSea(contract_address, web3)
-
-        title, symbol = self.generate_collection_data()
-
-        omnisea.create(account, title, symbol)
-
-    @staticmethod
-    def generate_collection_data():
-        title = "".join(random.sample([chr(i) for i in range(97, 123)], random.randint(5, 15)))
-        symbol = "".join(random.sample([chr(i) for i in range(65, 91)], random.randint(3, 6)))
-        return title, symbol
-
-    def log(self):
-        return "OMNI SEA COLLECTION"

web3_wizzard_lib/core/modules/nft/omnizone.py

@@ -1,25 +0,0 @@
-from sybil_engine.contract.send import Send
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Omnizone(SubModule):
-    module_name = 'OMNIZONE'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['OMNIZONE']
-
-        send = Send(None, web3)
-        send.send_to_wallet(
-            account, contract_address, NativeBalance(0, chain, "ETH"), "0x1249c58b"
-        )
-
-    def log(self):
-        return "OMNIZONE NFT"

web3_wizzard_lib/core/modules/nft/orbiter_claim.py

@@ -1,87 +0,0 @@
-import requests
-from eth_account import Account
-from eth_account.messages import encode_defunct
-from loguru import logger
-from sybil_engine.contract.send import Send
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.domain.balance.balance import NativeBalance
-from sybil_engine.utils.web3_utils import init_web3
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class OrbiterClaim(SubModule):
-    module_name = 'ORBITER_CLAIM'
-
-    nft_address = "0x13dFDd3a9B39323F228Daf73B62C23F7017E4679"
-
-    def execute(self, account, chain='ARBITRUM'):
-
-        # message to sign Orbiter Airdrop
-        message_text = "Orbiter Airdrop"
-        text_hex = "0x" + message_text.encode('utf-8').hex()
-        text_encoded = encode_defunct(hexstr=text_hex)
-        signed_message = Account.sign_message(text_encoded, private_key=account.key)
-
-        signature = f'0x{signed_message.signature.hex()}'
-        headers = {
-            "token": signature
-        }
-
-        result = requests.post(
-            "https://airdrop-api.orbiter.finance/airdrop/snapshot",
-            headers=headers
-        ).json()
-
-        chain_id = result['result']['chainId']
-
-        chain, data = self.form_data(chain, chain_id, result)
-
-        try:
-            self.send_transaction(account, chain, data)
-        except Exception as e:
-            self.send_transaction(account, chain, data.replace("0000000000000000014", "0000000000000000013"))
-
-    def form_data(self, chain, chain_id, result):
-        amount_str = result['result']['proof'][0]['amount']
-        logger.info(f"Orbiter Airdrop snapshot result: {amount_str}")
-        amount_int = int(amount_str.replace(".", ""))
-        logger.info(f"AMOUNT INT: {amount_int}")
-        hex_value = hex(amount_int)[2:]
-        logger.info(f"AMOUNT: {hex_value}")
-        logger.info(f"HEX {hex_value}")
-        if int(chain_id) == 42161:
-            chain = 'ARBITRUM'
-            data = "0xfa5c4e99071cbb2ff029ddaf4b691745b2ba185cbe9ca2f5fa9e7358bada8fbdce764291"
-            data += f"0000000000000000000000000000000000000000000000{hex_value}00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000014"
-        else:
-            data = "0xfa5c4e995d32ba2a988b8fa6c2ae96d3b5980c67e8d8cfbf0d4c89479b79c1e277843438"
-            data += f"000000000000000000000000000000000000000000000010b202b565eb37160000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000010"
-            chain = 'BASE'
-        for line_data in result['result']['proof'][0]['data']:
-            data += line_data[2:]
-        logger.info(data)
-        return chain, data
-
-    def send_transaction(self, account, chain, data):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-        Send(None, web3).send_to_wallet(
-            account,
-            self.nft_address,
-            NativeBalance(0, chain, "ETH"),
-            data
-        )
-
-    def log(self):
-        return "ORBITER NFT"
-
-def round_to_custom_precision(number, precision):
-    # Find the rounding factor (10^precision)
-    factor = 10 ** precision
-    # Perform rounding
-    return round(number / factor) * factor
-
-
-def truncate_to_decimal_places(value, decimals):
-    factor = 10 ** decimals
-    return int(float(int(value * factor)) / factor)

web3_wizzard_lib/core/modules/nft/readon.py

@@ -1,30 +0,0 @@
-import random
-
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.readon_contract import ReadOnContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class ReadOn(SubModule):
-    module_name = 'READON'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['READON']
-        readon_curate = ReadOnContract(contract_address, web3)
-
-        low = 1700890697805328281
-        high = 1709890697805328281
-
-        # Generate a random number within the given range
-        contentUrl = format(random.randint(low, high), 'x').zfill(64)
-
-        readon_curate.curate(account, contentUrl)
-
-    def log(self):
-        return "READON NFT"

web3_wizzard_lib/core/modules/nft/rubyscore.py

@@ -1,45 +0,0 @@
-import requests
-from eth_account import Account
-from eth_account.messages import encode_defunct
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.rubyscore_contract import RubyscoreContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Rubyscore(SubModule):
-    module_name = 'RUBYSCORE'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        message = " A signature is required for authorization on the platform and does not pose a threat to users!"
-
-        message_encoded = encode_defunct(text=message)
-        signed_message = Account.sign_message(message_encoded, private_key=account.key).signature.hex()
-
-        login_request_url = f"https://rubyscore.io/api/auth/login?signature={signed_message}&message=+A+signature+is+required+for+authorization+on+the+platform+and+does+not+pose+a+threat+to+users!&wallet={account.address}"
-
-        login_token = requests.post(login_request_url).json()['result']['token']
-
-        request_signature_request = "https://rubyscore.io/api/attestation/claim?project=linea"
-        request_signature_response = requests.post(
-            request_signature_request,
-            headers={
-                'Authorization': f'Bearer {login_token}'
-            }
-        ).json()['result']
-
-        schemaId = request_signature_response['attestationParams']['schemaId']
-        expirationDate = int(request_signature_response['attestationParams']['expirationDate'])
-        signature = request_signature_response['signature']
-
-        contract_address = get_contracts_for_chain(chain)['RUBYSCORE']
-        rubyscore = RubyscoreContract(contract_address, web3)
-        rubyscore.attest_rubyscore(account, signature, schemaId, expirationDate)
-
-    def log(self):
-        return "RUBYSCORE"

web3_wizzard_lib/core/modules/nft/sarubol.py

@@ -1,22 +0,0 @@
-from sybil_engine.data.contracts import get_contracts_for_chain
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.alienswap_contract import AlienSwapContract
-from web3_wizzard_lib.core.utils.sub_module import SubModule
-
-
-class Sarubol(SubModule):
-    module_name = 'SARUBOL'
-
-    def execute(self, account, chain='LINEA'):
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract_address = get_contracts_for_chain(chain)['SARUBOL']
-        sarubol_nft = AlienSwapContract(contract_address, web3)
-
-        sarubol_nft.purchase(account, 1)
-
-    def log(self):
-        return "SARUBOL NFT"