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

web3_wizzard_lib/core/modules/nft/lucky_cat.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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