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

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"

web3_wizzard_lib/core/modules/nft/satoshi_universe.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.satoshi_universe_contract import SatoshiUniverseContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class SatoshiUniverse(SubModule):
+    module_name = 'SATOSHI_UNIVERSE'
+
+    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)['SATOSHI_UNIVERSE']
+        satoshi_universe = SatoshiUniverseContract(contract_address, web3)
+
+        satoshi_universe.mint(account, 1)
+
+    def log(self):
+        return "SATOSHI UNIVERSE NFT"

web3_wizzard_lib/core/modules/nft/scroll_canvas_attest_year_badge.py

@@ -0,0 +1,35 @@
+import requests
+from sybil_engine.contract.send import Send
+from sybil_engine.domain.balance.balance import NativeBalance
+from sybil_engine.domain.balance.balance_utils import from_eth_to_wei
+from sybil_engine.utils.app_account_utils import AppAccount
+
+from web3_wizzard_lib.core.modules.nft.nft_submodule import NftSubmodule
+
+
+class ScrollCanvas1YearBadge(NftSubmodule):
+    module_name = 'SCROLL_CANVAS_YEAR_BADGE'
+    nft_address = '0x3dacAd961e5e2de850F5E027c70b56b5Afa5DfeD'
+
+    def execute(self, account: AppAccount, chain='SCROLL', wei_cost=from_eth_to_wei(0)):
+        url = f"https://canvas.scroll.cat/badge/claim?badge={self.nft_address}&recipient={account.address}"
+
+        proxy = {
+            'http': account.proxy,
+            'https': account.proxy
+        }
+
+        result = requests.get(url, proxies=proxy).json()
+
+        Send(
+            None,
+            self.create_web3(account, chain)
+        ).send_to_wallet(
+            account,
+            result['tx']['to'],
+            NativeBalance(wei_cost, chain, "ETH"),
+            result['tx']['data']
+        )
+
+    def log(self):
+        return "SCROLL CANVAS (1 YEAR BADGE)"

web3_wizzard_lib/core/modules/nft/scroll_canvas_mint.py

@@ -0,0 +1,51 @@
+import random
+import string
+
+import requests
+from loguru import logger
+from sybil_engine.domain.balance.balance_utils import from_eth_to_wei
+from sybil_engine.utils.app_account_utils import AppAccount
+
+from web3_wizzard_lib.core.contract.scroll_canvas_mint_contract import ScrollCanvasMintContract
+from web3_wizzard_lib.core.modules.nft.nft_submodule import NftSubmodule
+
+
+class ScrollCanvasMint(NftSubmodule):
+    module_name = 'SCROLL_CANVAS_MINT'
+    nft_address = '0xB23AF8707c442f59BDfC368612Bd8DbCca8a7a5a'
+
+    def execute(self, account: AppAccount, wei_cost=from_eth_to_wei(0.0005), chain='SCROLL'):
+        contract = ScrollCanvasMintContract(
+            '0xB23AF8707c442f59BDfC368612Bd8DbCca8a7a5a',
+            self.create_web3(account, chain)
+        )
+
+        username = self.generate_username(random.randint(8, 12))
+        referral = random.choice(self.get_referrals())
+
+        logger.info(f"Mint Scroll Canvas with username {username} using ref {referral}")
+
+        contract.mint(
+            account,
+            username,
+            requests.get(f'https://canvas.scroll.cat/code/{referral}/sig/{account.address}').json()['signature'],
+            wei_cost
+        )
+
+    def log(self):
+        return "SCROLL CANVAS MINT"
+
+    def generate_username(self, length):
+        # Combine uppercase, lowercase letters and digits
+        characters = string.ascii_letters + string.digits
+        # Generate random string
+        random_string = ''.join(random.choice(characters) for _ in range(length))
+        return random_string
+
+    def get_referrals(self):
+        return [
+            'POPNK',
+            'GTNPB',
+            'KZFXI',
+            'MFWQ7'
+        ]

web3_wizzard_lib/core/modules/nft/sign.py

@@ -0,0 +1,32 @@
+from json import dumps
+
+import requests
+from eth_account.messages import encode_defunct
+
+
+def sign_in_message(account, web3):
+    message_text = "Please sign this message to confirm you are the owner of this address and Sign in to TrustGo App"
+    signature = sign_msg(account, message_text, web3)
+    url = 'https://mp.trustalabs.ai/accounts/check_signed_message'
+    data = {
+        "mode": "evm", "address": account.address,
+        "message": message_text,
+        "signature": signature,
+        "invite_from": {"from": "0", "code": 'EPR0QD9W52I8'}}
+    headers = {'Authorization': f'TOKEN null', 'Accept': 'application/json'}
+    data_json = dumps(data)
+    r = requests.post(url, data=data_json, headers=headers)
+    if r.status_code == 200:
+        res = [r.json()]
+        if res[0]['code'] == 0:
+            token_auth = res[0]['data']['token']
+            return token_auth
+    return -1
+
+
+def sign_msg(wallet, message_text, web3):
+    text_hex = "0x" + message_text.encode('utf-8').hex()
+    text_encoded = encode_defunct(hexstr=text_hex)
+    signed_message = web3.eth.account.sign_message(text_encoded, private_key=wallet.key)
+    signature = signed_message.signature
+    return signature.hex()

web3_wizzard_lib/core/modules/nft/snap.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 Snap(SubModule):
+    module_name = 'SNAP'
+
+    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)['SNAP']
+
+        send = Send(None, web3)
+        send.send_to_wallet(
+            account, contract_address, NativeBalance(0, chain, "ETH"), "0x14f710fe"
+        )
+
+    def log(self):
+        return "SNAP MINT NFT"

web3_wizzard_lib/core/modules/nft/snap_bonus.py

@@ -0,0 +1,31 @@
+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.snap_contract import SnapContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class SnapBonus(SubModule):
+    module_name = 'SNAP_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)['SNAP']
+        social_scan = SnapContract(contract_address, web3)
+
+        balance = social_scan.contract.functions.balanceOf(account.address).call()
+        token_id = social_scan.contract.functions.tokenOfOwnerByIndex(account.address, 0).call()
+
+        if balance == 0:
+            logger.error(f"[{account.app_id}][{account.address}] Not found NFT. Skip module")
+            return
+
+        social_scan.stake(account, token_id)
+
+    def log(self):
+        return "SNAP_BONUS MINT NFT"

web3_wizzard_lib/core/modules/nft/social_scan.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.social_scan_contract import SocialScanContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class SocialScan(SubModule):
+    module_name = 'SOCIAL_SCAN'
+
+    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)['SOCIAL_SCAN']
+        social_scan = SocialScanContract(contract_address, web3)
+
+        social_scan.set_approval_for_all(account, '0x0caB6977a9c70E04458b740476B498B214019641', True)
+
+    def log(self):
+        return "SOCIAL SCAN NFT"

web3_wizzard_lib/core/modules/nft/sub_module.py

@@ -0,0 +1,8 @@
+class SubModule:
+    module_name = None
+
+    def execute(self, *args):
+        pass
+
+    def log(self):
+        pass

web3_wizzard_lib/core/modules/nft/tavaera.py

@@ -0,0 +1,30 @@
+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.tavaera_id import TavaeraID
+from web3_wizzard_lib.core.contract.tavaera_mint import Tavaera
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class TavaeraModule(SubModule):
+    module_name = 'TAVAERA'
+
+    def execute(self, account, chain='ZKSYNC'):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        chain_contracts = get_contracts_for_chain(chain)
+
+        tavaera_id = TavaeraID(chain_contracts['TAVAERA_ID'], web3)
+        tavaera = Tavaera(chain_contracts['TAVAERA_MINT'], web3)
+
+        logger.info("Mint Tavaera ID")
+        tavaera_id.mint_citizen_id(account)
+
+        logger.info("Mint Tavaera NFT")
+        tavaera.mint(account)
+
+    def log(self):
+        return "CREATE TAVAERA ACCOUNT"

web3_wizzard_lib/core/modules/nft/townstory.py

@@ -0,0 +1,75 @@
+from json import dumps
+from time import time
+
+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.townstory_contract import TownstoryContract
+from web3_wizzard_lib.core.modules.nft.sign import sign_msg
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class Townstory(SubModule):
+    module_name = 'TOWNSTORY'
+
+    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)['TOWNSTORY']
+
+        message_text = get_message(account)
+        message_signature = sign_msg(account, message_text, web3)
+        txn_signature, deadline = get_txn_signature(account, message_signature)
+
+        townstory_contract = TownstoryContract(contract_address, web3)
+
+        townstory_contract.create_account_sign(account, txn_signature, deadline)
+
+    def log(self):
+        return "CREATE TOWNSTORY ACOUNT"
+
+
+def get_txn_signature(account, message_signature):
+    data = {"header": {"version": "1.0.1", "baseVersion": "1.0.0", "referer": ""},
+            "transaction": {"func": "register.loginByWallet",
+                            "params": {"hall": 0, "wallet": "metamask", "chain": "linea",
+                                       "signature": message_signature, "address": account.address}}}
+    json_data = dumps(data)
+    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+    url1 = 'https://aws-login.townstory.io/town-login/handler.php'
+    r = requests.get(url1, data=json_data, headers=headers)
+    response = r.json()
+    if response['result'] != 'failed':
+        txn_signature = r.json()['response']['signature']
+        deadline = r.json()['response']['deadline']
+        return txn_signature, deadline
+
+
+def get_time_nonce():
+    time_nonce = int(time() / 86400)
+    return time_nonce
+
+
+def get_address_line(address):
+    address_line = (address[:19] + '...' + address[-18:]).lower()
+    return address_line
+
+
+def get_message(wallet):
+    nonce = get_time_nonce()
+    address_line = get_address_line(wallet.address)
+    message = ('Welcome to Town Story! \n\n'
+               'Click to sign in and accept the Town Story\n'
+               'Terms of Service:\n'
+               'https://townstory.io/\n\n'
+               'This request will not trigger a blockchain\n'
+               'transaction or cost any gas fees.\n\n'
+               'Your authentication status will reset after\n'
+               'each session.\n\n'
+               'Wallet address:\n'
+               f'{address_line}\n\n'
+               f'Nonce: {nonce}')
+    return message

web3_wizzard_lib/core/modules/nft/townstory_bonus.py

@@ -0,0 +1,45 @@
+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.townstory_bonus_contract import TownstoryBonusContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class TownstoryBonus(SubModule):
+    module_name = 'TOWNSTORY_BONUS'
+
+    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)['TOWNSTORY_BONUS']
+
+        townstory_bonus_contract = TownstoryBonusContract(contract_address, web3)
+
+        signature, deadline = get_travelbag_signature(account.address, account.proxy)
+
+        townstory_bonus_contract.claim_linea_travelbag(account, signature, deadline)
+
+    def log(self):
+        return "CREATE TOWNSTORY BONUS"
+
+
+def get_travelbag_signature(wallet, proxy):
+    proxies = {'http': proxy,
+               'https': proxy}
+    url = 'https://townstory.io//api'
+    headers = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        "Content-Length": "70",
+        "Accept": "*/*",
+        "Origin": "https://townstory.io",
+        "Referer": "https://townstory.io/linea"
+
+    }
+    data = {"action": "getLineaSign", "address": f'{wallet.lower()}'}
+
+    r = requests.post(url, data=data, headers=headers, proxies=proxies)
+    res = r.json()
+    return res['signature'], res['deadline']

web3_wizzard_lib/core/modules/nft/trusta_reputation.py

@@ -0,0 +1,48 @@
+import requests
+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.modules.nft.sign import sign_in_message
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class TrustaReputation(SubModule):
+    module_name = 'TRUSTA_REPUTATION'
+
+    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)['TRUSTA_POH']
+
+        token_auth = sign_in_message(account, web3)
+        txn_calldata = get_attest_data_media(token_auth)
+
+        score = txn_calldata['message']['score']
+        if score < 20:
+            raise Exception(f'Score кошелька менее 20: score = {score}, аттестация не выполняется')
+
+        send = Send(contract_address, web3)
+        send.send_to_wallet(
+            account,
+            contract_address,
+            NativeBalance(txn_calldata['calldata']['value'], chain, 'ETH'),
+            txn_calldata['calldata']['data']
+        )
+
+    def log(self):
+        return "TRUSTA REPUTATION (Group B)"
+
+
+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/trustaa_poh.py

@@ -0,0 +1,49 @@
+import requests
+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.modules.nft.sign import sign_in_message
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class TrustaPoh(SubModule):
+    module_name = 'TRUSTA_POH'
+
+    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)['TRUSTA_POH']
+
+        token_auth = sign_in_message(account, web3)
+        txn_calldata = get_attest_data_humanity(token_auth)
+
+        score = txn_calldata['message']['score']
+        if score != -1:
+            raise Exception(f'Score кошелька равен {score}, аттестация не выполняется')
+
+        send = Send(contract_address, web3)
+        send.send_to_wallet(
+            account,
+            contract_address,
+            NativeBalance(txn_calldata['calldata']['value'], chain, 'ETH'),
+            txn_calldata['calldata']['data']
+        )
+
+    def log(self):
+        return "TRUSTA POH (Group A)"
+
+
+def get_attest_data_humanity(token_auth):
+    url = 'https://mp.trustalabs.ai/accounts/attest_calldata?attest_type=humanity'
+    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
+