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

core/modules/nft/linea_ens_names.py

@@ -1,107 +0,0 @@
-from random import choices
-from string import ascii_letters, digits
-
-import requests
-from eth_utils import keccak
-from faker import Faker
-from loguru import logger
-from sybil_engine.data.networks import get_chain_instance
-from sybil_engine.utils.app_account_utils import AppAccount
-from sybil_engine.utils.retry import retry
-from sybil_engine.utils.web3_utils import init_web3
-
-from web3_wizzard_lib.core.contract.linea_ens_names_contract import LineaEnsNamesContract
-from web3_wizzard_lib.core.modules import SubModule
-from web3_wizzard_lib.core.modules import SkipRetryException
-
-
-class LineaENSNames(SubModule):
-    module_name = 'LINEA_ENS'
-    nft_address = '0xDb75Db974B1F2bD3b5916d503036208064D18295'
-
-    def execute(self, account: AppAccount, chain='LINEA'):
-        self.sleep_after_conf = True
-
-        chain_instance = get_chain_instance(chain)
-        web3 = init_web3(chain_instance, account.proxy)
-
-        contract = LineaEnsNamesContract(self.nft_address, web3)
-
-        linea_name = self.get_available_name(contract)
-
-        if contract.redeemed(account):
-            #logger.info("[+] Web3 | Wallet already redeemed Linea name.")
-            raise SkipRetryException("[+] Web3 | Wallet already redeemed Linea name.")
-
-        logger.info(f"Minting {linea_name}.linea.eth for {account.address}")
-        duration = 60 * 60 * 24 * 365 * 3  # 3 years
-        secret, data = self.commit(account, linea_name, duration, contract)
-
-        # Uncomment the following line to perform the registration
-        self.register_poh(account, contract, data, duration, linea_name, secret)
-
-    def get_available_name(self, contract):
-        while True:
-            linea_name = self.generate_linea_name()
-            if contract.available(linea_name):
-                break
-            logger.warning(f'[-] Web3 | Linea name "{linea_name}.linea.eth" is unavailable. Retrying...')
-        return linea_name
-
-    @retry(max_attempts=20, retry_interval={'from': 10, 'to': 20})
-    def register_poh(self, account, contract, data, duration, linea_name, secret):
-        contract.register_poh(account, linea_name, duration, secret, data, self.get_poh_signature(account))
-
-    def generate_linea_name(self):
-        return Faker().user_name().replace('_', '-')
-
-    def log(self):
-        return "LINEA ENS"
-
-    def commit(self, account, linea_name: str, duration: int, linea_ens_contract):
-        secret = "0x" + ''.join(choices(ascii_letters + digits, k=10)).encode().hex().ljust(64, '0')
-        hashed_name = self.namehash(f"{linea_name}.linea.eth")
-        data = linea_ens_contract.addr_contract.functions.setAddr(
-            hashed_name, 60,
-            account.address
-        )._encode_transaction_data()
-
-        commitment = linea_ens_contract.make_commitment(
-            account,
-            linea_name,
-            duration,
-            secret,
-            data,
-        )
-
-        linea_ens_contract.commit(account, commitment)
-
-        return secret, data
-
-    def namehash(self, name: str):
-        labels = name.split('.')
-        labels.reverse()
-        result = "0000000000000000000000000000000000000000000000000000000000000000"
-
-        for label in labels:
-            hashed = keccak(text=label).hex()
-            result = keccak(hexstr=result + hashed).hex()
-
-        return "0x" + result
-
-    def sleep_after_conf(self):
-        return self.sleep_after_conf
-
-    def get_poh_signature(self, account):
-        headers = {
-            "Origin": "https://relay.link",
-            "Referer": "https://relay.link/"
-        }
-
-        r = requests.get(f'https://linea-poh-signer-api.linea.build/poh/{account.address}', headers=headers)
-        if len(r.text) == 132 and r.text.startswith("0x"):
-            return {"sign": r.text, "success": True, "msg": ""}
-        elif "address not POH" in r.text:
-            return {"sign": "", "success": False, "msg": "This wallet dont have POH"}
-        else:
-            raise Exception(r.text)

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.modules 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"

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.modules 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"

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.modules 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"

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.modules 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"

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.modules 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)

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.modules 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

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.modules 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"

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.modules 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

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.modules 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"

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.modules 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"

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.modules 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"

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.modules 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"

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.modules 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"

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.modules 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)