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

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/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
+

web3_wizzard_lib/core/modules/nft/uber_poh.py

@@ -0,0 +1,24 @@
+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 UberPoh(SubModule):
+    module_name = 'UBER_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)['UBER_POH']
+
+        send = Send(None, web3)
+        send.send_to_wallet(
+            account, contract_address, NativeBalance(0, chain, "ETH"), account.notes)
+
+    def log(self):
+        return "UBER POH"

web3_wizzard_lib/core/modules/nft/wizards_of_linea.py

@@ -0,0 +1,26 @@
+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.app_account_utils import AppAccount
+from sybil_engine.utils.web3_utils import init_web3
+
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class WizzardsOfLinea(SubModule):
+    module_name = 'LINEA_CULTURE_4'
+
+    def execute(self, account: AppAccount, chain='LINEA'):
+        chain_instance = get_chain_instance(chain)
+        web3 = init_web3(chain_instance, account.proxy)
+
+        send = Send(None, web3)
+        send.send_to_wallet(
+            account,
+            '0xD540038B0B427238984E0341bA49F69CD80DC139',
+            NativeBalance(0, chain, "ETH"),
+            "0x00000000"
+        )
+
+    def log(self):
+        return "WIZZARDS OF LINEA"

web3_wizzard_lib/core/modules/nft/yoddlo.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.yoddlo_contract import YoddloContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class Yoddlo(SubModule):
+    module_name = 'YODDLO'
+
+    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)['YODDLO']
+        yoddlo_nft = YoddloContract(contract_address, web3)
+
+        yoddlo_nft.purchase(account)
+
+    def log(self):
+        return "YODDLO NFT"

web3_wizzard_lib/core/modules/nft/yuliverse.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.yuliverse_contract import YuliverseContract
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class Yuliverse(SubModule):
+    module_name = 'YULIVERSE'
+
+    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)['YULIVERSE']
+        yuliverse_nft = YuliverseContract(contract_address, web3)
+
+        yuliverse_nft.purchase(account)
+
+    def log(self):
+        return "YULIVERSE NFT"

web3_wizzard_lib/core/modules/nft/zace.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 Zace(SubModule):
+    module_name = 'ZACE'
+
+    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)['ZACE']
+
+        send = Send(None, web3)
+        send.send_to_wallet(
+            account, contract_address, NativeBalance(50000000000000, chain, "ETH"), "0xbaeb0718"
+        )
+
+    def log(self):
+        return "zAce NFT"

web3_wizzard_lib/core/modules/nft/zks_domain.py

@@ -0,0 +1,41 @@
+import random
+
+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.zks import ZKS
+from web3_wizzard_lib.core.utils.sub_module import SubModule
+
+
+class ZksDomain(SubModule):
+    module_name = 'TAVAERA'
+
+    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)['ZKS']
+        zks = ZKS(contract_address, web3)
+
+        domain_name = self.get_random_name(zks)
+
+        zks.register(account, domain_name)
+
+    def get_random_name(self, zks):
+        domain_name = "".join(random.sample([chr(i) for i in range(97, 123)], random.randint(7, 15)))
+
+        logger.info(f"Mint {domain_name}.zks domain")
+
+        check_name = zks.available(domain_name)
+
+        if check_name:
+            return domain_name
+
+        logger.info(f"{domain_name}.zks is unavailable, try another domain")
+
+        return self.get_random_name(zks)
+
+    def log(self):
+        return "REGISTER RANDOM ZKS DOMAIN"