init

bot-buyer.py

@@ -0,0 +1,112 @@
+from core import *
+
+# set config variables
+buy_percent_diff_pdai = 20
+buy_percent_diff_pusdc = 30
+buy_with_amount_pls = 10000
+slippage_percent = 5
+wallet_min_pls = 20000
+loop_delay = 3
+rapid_gas_fee_limit = 650000
+
+# load wallet A and set address for logging
+set_logging(wallet_a_address, 'INFO')
+account = load_wallet(wallet_a_address, os.getenv('SECRET'))
+
+# load contract addresses
+pdai_address = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
+pusdc_address = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+affection_address = '0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D'
+wpls_address = '0xA1077a294dDE1B09bB078844df40758a5D0f9a27'
+
+while True:
+    # log the wallet's pls balance
+    logging.info("PLS Balance: {:.15f}".format(get_pls_balance(account.address)))
+
+    # if wallet has at least 1 pdai token send it to the minter
+    if (pdai_balance := get_token_balance(pdai_address, wallet_a_address)) > 1:
+        if tx := send_tokens(account, pdai_address, wallet_b_address, pdai_balance):
+            logging.info("Sent {} pDAI to {}".format(pdai_balance, wallet_b_address))
+
+    # if wallet has at least 1 usdc token send it to the minter
+    if (pusdc_balance := get_token_balance(pusdc_address, wallet_a_address)) > 1:
+        if tx := send_tokens(account, pusdc_address, wallet_b_address, pusdc_balance):
+            logging.info("Sent {} pUSDC to {}".format(pusdc_balance, wallet_b_address))
+
+    # check the current gas price
+    if get_beacon_gas_prices('rapid', beacon_gasnow_cache_seconds) > rapid_gas_fee_limit:
+        logging.warning("Gas fees are too high")
+        log_end_loop(loop_delay)
+        continue
+
+    # take samples of 1 pdai/pusdc/affection to wpls price
+    pdai_sample_result = sample_exchange_rate('PulseX_v2', pdai_address, wpls_address)
+    pusdc_sample_result = sample_exchange_rate('PulseX_v2', pusdc_address, wpls_address)
+    affection_sample_result = sample_exchange_rate('PulseX_v2', affection_address, wpls_address)
+
+    # log the current rate
+    logging.info("pDAI Rate: 1 = {} PLS".format(pdai_sample_result / 10 ** 18))
+    logging.info("pUSDC Rate: 1 = {} PLS".format(pusdc_sample_result / 10 ** 18))
+    logging.info("AFFECTION™ Rate: 1 = {} PLS".format(affection_sample_result / 10 ** 18))
+
+    # keep a minimum pls balance in the bot
+    skip = False
+    if (pls_balance := get_pls_balance(wallet_a_address)) < wallet_min_pls:
+        logging.warning("PLS balance is below minimum")
+        skip = True
+    elif pls_balance < buy_with_amount_pls + wallet_min_pls:
+        logging.warning("Buying would put the PLS balance below minimum")
+        skip = True
+    if skip:
+        log_end_loop(loop_delay)
+        continue
+
+    # check if the pdai price is cheaper than affection price
+    if pdai_sample_result < affection_sample_result:
+        percent_diff = ((pdai_sample_result - affection_sample_result) / affection_sample_result) * 100
+        # pdai price must be cheaper and over the diff threshold
+        if percent_diff < 0 and abs(percent_diff) >= buy_percent_diff_pdai:
+            logging.info("Buying pDAI...")
+            # get the estimated amounts returned for the swap
+            estimated_swap_result = estimate_swap_result(
+                'PulseX_v2',
+                wpls_address,
+                pdai_address,
+                buy_with_amount_pls
+            )
+            # broadcast swap pls for pusdc
+            if swap_tokens(
+                account,
+                'PulseX_v2',
+                [wpls_address, pdai_address],
+                estimated_swap_result,
+                slippage_percent
+            ):
+                logging.info("Swapped {} PLS to pDAI".format(buy_with_amount_pls))
+
+    # check if the pusdc price is cheaper than affection price
+    if pusdc_sample_result < affection_sample_result:
+        # check the percent difference
+        percent_diff = ((pusdc_sample_result - affection_sample_result) / affection_sample_result) * 100
+        # pusdc price must be cheaper and over the diff threshold
+        if percent_diff < 0 and abs(percent_diff) >= buy_percent_diff_pusdc:
+            logging.info("Buying pUSDC...")
+            # get the estimated amounts returned for the swap
+            estimated_swap_result = estimate_swap_result(
+                'PulseX_v2',
+                wpls_address,
+                pusdc_address,
+                buy_with_amount_pls
+            )
+            # broadcast swap pls for pdai
+            if swap_tokens(
+                account,
+                'PulseX_v2',
+                [wpls_address, pusdc_address],
+                estimated_swap_result,
+                slippage_percent
+            ):
+                logging.info("Swapped {} PLS to pUSDC".format(buy_with_amount_pls))
+
+    # wait before next loop
+    log_end_loop(loop_delay)

bot-minter.py

@@ -0,0 +1,114 @@
+from core import *
+
+# set config variables
+wallet_min_pls = 20000
+loop_delay = 3
+rapid_gas_fee_limit = 650000
+
+# load wallet B and set address for logging
+set_logging(wallet_b_address, 'INFO')
+account = load_wallet(wallet_b_address, os.getenv('SECRET'))
+
+# load affection contract/info
+affection_address = '0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D'
+affection_info = get_token_info(affection_address)
+affection_contract = load_contract(affection_address)
+
+# load pdai contract/info
+pdai_address = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
+pdai_info = get_token_info(pdai_address)
+pdai_contract = load_contract(pdai_address)
+
+# load pusdc contract/info
+pusdc_address = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
+pusdc_info = get_token_info(pusdc_address)
+pusdc_contract = load_contract(pusdc_address)
+
+# load pi contract/info
+pi_address = '0xA2262D7728C689526693aE893D0fD8a352C7073C'
+pi_info = get_token_info(pi_address)
+pi_contract = load_contract(pi_address)
+
+# load g5 contract/info
+g5_address = '0x2fc636E7fDF9f3E8d61033103052079781a6e7D2'
+g5_info = get_token_info(g5_address)
+g5_contract = load_contract(g5_address)
+
+# load math 1.1 contract/info
+math11_address = '0xB680F0cc810317933F234f67EB6A9E923407f05D'
+math11_info = get_token_info(math11_address)
+math11_contract = load_contract(math11_address)
+
+# load multi contract addresses
+multi_affection_address = '0x79474ff39B0F9Dc7d5F7209736C2a6913cf50F82'
+multi_math_1_1_address = '0x98375dA84C1493767De695Ee7Eef0BB522380A07'
+multi_g5_address = '0x5092aE511259E69e7D184fE69f4603108c143feF'
+multi_pi_address = '0x20c1DA6b3A2a3EA46a3c2CFeBB9Ac71E239d355A'
+
+while True:
+    # log the wallet's pls balance
+    logging.info("PLS Balance: {:.15f}".format(pls_balance := get_pls_balance(account.address)))
+
+    # transfer affection
+    logging.info("AFFECTION™ Balance: {:.15f}".format(affection_balance := float(round(get_token_balance(affection_address, wallet_b_address), 2))))
+    if affection_balance > 1:
+        # send affection tokens to wallet C for selling
+        if send_tokens(account, affection_address, wallet_c_address, affection_balance):
+            logging.info("Sent {} AFFECTION™ to {}".format(affection_balance, wallet_c_address))
+
+    # check the current gas price
+    if get_beacon_gas_prices('rapid', beacon_gasnow_cache_seconds) > rapid_gas_fee_limit:
+        logging.warning("Gas fees are too high")
+        log_end_loop(loop_delay)
+        continue
+
+    # keep a minimum pls balance in the bot
+    if pls_balance < wallet_min_pls:
+        logging.info("PLS balance is below minimum threshold")
+        log_end_loop(loop_delay)
+        continue
+
+    # convert pdai to pi
+    logging.info("pDAI Balance: {:.15f}".format(pdai_balance := get_token_balance(pdai_address, wallet_b_address)))
+    if (loops := math.floor(pdai_balance / 300)) != 0:
+        logging.info("Converting {} pDAI to PI...".format(loops))
+        convert_tokens_multi(account, multi_pi_address, pdai_address, pi_address, loops)
+
+    # convert pdai to g5
+    pdai_balance = get_token_balance(pdai_address, wallet_b_address)
+    if (loops := math.floor(pdai_balance / 5)) != 0:
+        logging.info("Converting {} pDAI to G5...".format(loops))
+        convert_tokens_multi(account, multi_g5_address, pdai_address, g5_address, loops)
+
+    # convert pdai to math1.1
+    pdai_balance = get_token_balance(pdai_address, wallet_b_address)
+    if (loops := math.floor(pdai_balance)) != 0:
+        logging.info("Converting {} pDAI to MATH v1.1 ...".format(loops))
+        convert_tokens_multi(account, multi_math_1_1_address, pdai_address, math11_address, loops)
+
+    # convert pusdc to math1.1
+    logging.info("pUSDC Balance: {:.15f}".format(pusdc_balance := get_token_balance(pusdc_address, wallet_b_address)))
+    if (loops := math.floor(pusdc_balance)) != 0:
+        logging.info("Converting {} pUSDC to MATH v1.1 ...".format(loops))
+        convert_tokens_multi(account, multi_math_1_1_address, pusdc_address, math11_address, loops)
+
+    # convert pi to affection
+    logging.info("PI Balance: {:.15f}".format(pi_balance := get_token_balance(pi_address, wallet_b_address)))
+    if (loops := math.floor(pi_balance / 0.01)) != 0:
+        logging.info("Converting {} PI to AFFECTION™...".format(loops * 0.01))
+        convert_tokens_multi(account, multi_affection_address, pi_address, affection_address, loops)
+
+    # convert g5 to affection
+    logging.info("G5 Balance: {:.15f}".format(g5_balance := get_token_balance(g5_address, wallet_b_address)))
+    if (loops := math.floor(g5_balance / 0.6)) != 0:
+        logging.info("Converting {} G5 to AFFECTION™...".format(loops * 0.6))
+        convert_tokens_multi(account, multi_affection_address, g5_address, affection_address, loops)
+
+    # convert math 1.1 to affection
+    logging.info("MATH 1.1 Balance: {:.15f}".format(math11_balance := get_token_balance(math11_address, wallet_b_address)))
+    if (loops := math.floor(math11_balance / 3)) != 0:
+        logging.info("Converting {} MATH v1.1 to AFFECTION™...".format(loops * 3))
+        convert_tokens_multi(account, multi_affection_address, math11_address, affection_address, loops)
+
+    # wait before next loop
+    log_end_loop(loop_delay)

bot-seller.py

@@ -0,0 +1,96 @@
+from core import *
+
+# set config variables
+sell_percent_diff_affection = 0
+sell_with_amount_affection = 200
+slippage_percent = 5
+wallet_min_pls = 20000
+loop_delay = 3
+loop_sell_delay = 10
+rapid_gas_fee_limit = 650000
+
+# load wallet C and set address for logging
+set_logging(wallet_c_address, 'INFO')
+account = load_wallet(wallet_c_address, os.getenv('SECRET'))
+
+# load affection contract/info
+affection_address = '0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D'
+affection_info = get_token_info(affection_address)
+affection_contract = load_contract(affection_address)
+affection_sample_result_last = None
+
+# load wpls contract/info
+wpls_address = '0xA1077a294dDE1B09bB078844df40758a5D0f9a27'
+wpls_info = get_token_info(wpls_address)
+wpls_contract = load_contract(wpls_address)
+
+while True:
+    # log the wallet's pls balance
+    logging.info("PLS Balance: {:.15f}".format(get_pls_balance(account.address)))
+
+    # send pls back to wallet a for buying
+    pls_balance = get_pls_balance(account.address, False)
+    pls_balance -= wallet_min_pls
+    # send the minter 1/3
+    send_to_wallet_b = float(round(pls_balance / 4, 2))
+    # send the rest to buyer
+    send_to_wallet_a = float(round(pls_balance - send_to_wallet_b, 2))
+    if pls_balance > wallet_min_pls:
+        # send pls to wallet a
+        if send_pls(account, wallet_a_address, send_to_wallet_a):
+            logging.info("Sent {} PLS to {}".format(send_to_wallet_a, wallet_a_address))
+        else:
+            logging.warning("Failed to send {} PLS to {}".format(send_to_wallet_a, wallet_a_address))
+        # send pls to wallet b
+        if send_pls(account, wallet_b_address, send_to_wallet_b):
+            logging.info("Sent {} PLS to {}".format(send_to_wallet_b, wallet_b_address))
+        else:
+            logging.warning("Failed to send {} PLS to {}".format(send_to_wallet_b, wallet_b_address))
+
+    # check the current gas price
+    if get_beacon_gas_prices('rapid', beacon_gasnow_cache_seconds) > rapid_gas_fee_limit:
+        logging.warning("Gas fees are too high")
+        log_end_loop(loop_delay)
+        continue
+
+    # take a sample of the 1 affection to wpls price
+    affection_sample_result = sample_exchange_rate('PulseX_v2', affection_address, wpls_address)
+    if not affection_sample_result_last:
+        affection_sample_result_last = affection_sample_result
+
+    # log the current rate
+    logging.info("AFFECTION™ Rate: 1 = {} PLS".format(affection_sample_result / 10 ** 18))
+    logging.info("AFFECTION™ Balance: {:.15f}".format(affection_balance := get_token_balance(affection_address, wallet_c_address), 2))
+    # check if wallet c has at least 1 token to sell
+    if affection_balance > 1:
+        # get amounts of affection to sell
+        sells = math.floor(affection_balance / sell_with_amount_affection)
+        selling_amounts = [sell_with_amount_affection] * sells
+        selling_amounts.append(math.floor(affection_balance - sum(selling_amounts)))
+        # start selling affection in different amounts
+        logging.info("Selling {} AFFECTION™...".format(sum(selling_amounts)))
+        for i, amount in enumerate(selling_amounts):
+            estimated_swap_result = estimate_swap_result(
+                'PulseX_v2',
+                affection_address,
+                wpls_address,
+                amount
+            )
+            if swap_tokens(
+                account,
+                'PulseX_v2',
+                [affection_address, wpls_address],
+                estimated_swap_result,
+                slippage_percent
+            ):
+                logging.info("Swapped {} AFFECTION™ to PLS".format(amount))
+            # delay if amounts remain in the list
+            if i + 1 != len(selling_amounts):
+                logging.info("Waiting for {} seconds...".format(loop_sell_delay))
+                time.sleep(loop_sell_delay)
+
+    # save the last sample price
+    affection_sample_result_last = affection_sample_result
+
+    # wait before next loop
+    log_end_loop(loop_delay)

core.py

@@ -0,0 +1,702 @@
+import json
+import logging
+import math
+import os
+import random
+import sys
+import time
+from logging.handlers import TimedRotatingFileHandler
+from statistics import median, mean, mode
+
+import requests
+from dotenv import load_dotenv
+from requests import RequestException
+from web3 import Web3
+from web3.exceptions import BlockNotFound, Web3Exception, Web3ValidationError
+from web3_multi_provider import MultiProvider
+
+load_dotenv()
+for package in ('web3', 'web3_multi_provider', 'urllib3',):
+    logging.getLogger(package).setLevel(logging.ERROR)
+
+web3 = Web3(MultiProvider(json.load(open('./data/rpc_servers.json'))))
+
+gas_multiplier = float(os.getenv('GAS_MULTIPLIER'))
+rapid_gas_fee_limit = int(os.getenv('GAS_FEE_RAPID_LIMIT'))
+beacon_gasnow_cache_seconds = int(os.getenv('BEACON_GASNOW_CACHE_SECONDS'))
+wallet_a_address = os.getenv('WALLET_A_ADDRESS')
+wallet_b_address = os.getenv('WALLET_B_ADDRESS')
+wallet_c_address = os.getenv('WALLET_C_ADDRESS')
+
+
+def apply_estimated_gas(tx):
+    if 'gas' not in tx:
+        tx['gas'] = web3.eth.estimate_gas(tx)
+    return tx
+
+
+def apply_gas_multiplier(tx, multiplier=None):
+    if not multiplier:
+        multiplier = os.getenv('GAS_MULTIPLIER')
+    try:
+        multiplier = float(multiplier)
+    except ValueError:
+        raise ValueError("Invalid float for GAS_MULTIPLIER")
+    else:
+        tx['gas'] = int(tx['gas'] * multiplier)
+        if 'maxFeePerGas' in tx:
+            tx['maxFeePerGas'] = int(tx['maxFeePerGas'] * multiplier)
+        return tx
+
+
+def apply_median_gas_strategy(tx, tx_amount=100):
+    median_gas_price = get_average_gas_prices('median', tx_amount)['gas_price']
+    tx['maxFeePerGas'] = int(web3.to_wei(median_gas_price, 'wei'))
+    tx['maxPriorityFeePerGas'] = web3.to_wei(500, 'gwei')
+    return tx
+
+
+def approve_token_spending(account, token_address, spender_address, amount, attempts=18):
+    token_contract = load_contract(token_address)
+    token_info = get_token_info(token_address)
+    token_amount = to_token_decimals(amount, token_info['decimals'])
+    if token_contract.functions.allowance(account.address, spender_address).call() < token_amount:
+        tx = token_contract.functions.approve(spender_address, token_amount).build_transaction({
+            'nonce': get_nonce(account.address),
+            'from': account.address
+        })
+        try:
+            return broadcast_transaction(account, tx, True, attempts)
+        except Exception as e:
+            if error := interpret_exception_message(e):
+                logging.error("{} to approve {} ({})".format(error, token_info['name'], token_info['symbol']))
+            return False
+
+
+def broadcast_transaction(account, tx, auto_gas=True, attempts=18):
+    tx_hash = None
+    tx['chainId'] = 369
+    if not auto_gas:
+        tx = apply_estimated_gas(tx)
+        tx = apply_median_gas_strategy(tx)
+        tx = apply_gas_multiplier(tx)
+    logging.debug("Broadcasting TX: {}".format(tx))
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            signed_tx = web3.eth.account.sign_transaction(tx, private_key=account.key)
+            tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+        except Exception as e:
+            logging.debug(e)
+            if "insufficient funds" in str(e):
+                logging.error("Not enough gas for this TX: {}".format(tx))
+                return False
+            elif "nonce too low" in str(e):
+                tx['nonce'] = get_nonce(account.address)
+                continue
+            elif "could not replace existing tx" in str(e):
+                tx['gas'] = int(tx['gas'] * 1.0369)
+                if 'maxFeePerGas' in tx:
+                    tx['maxFeePerGas'] = int(tx['maxFeePerGas'] * 1.0369)
+                if 'maxPriorityFeePerGas' in tx:
+                    tx['maxPriorityFeePerGas'] = int(tx['maxPriorityFeePerGas'] * 1.0369)
+                continue
+            elif "already known" in str(e):
+                pass
+        if not tx_hash:
+            time.sleep(10)
+            _attempts -= 1
+            if _attempts != 0:
+                logging.debug("Rebroadcasting TX ... {}".format(attempts - _attempts))
+            continue
+        else:
+            try:
+                tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+            except Exception as e:
+                logging.debug(e)
+                _attempts -= 1
+                if _attempts != 0:
+                    logging.debug("Rebroadcasting TX ... {}".format(attempts - _attempts))
+            else:
+                logging.debug("Confirmed TX: {}".format(tx_receipt))
+                return tx_receipt
+
+
+def convert_tokens(account, token0_address, token1_address, output_amount, attempts=18):
+    # check if conversion route exists
+    routes_functions = json.load(open('./data/routes.json'))
+    if token0_address not in routes_functions[token1_address]['functions'].keys():
+        raise Exception("Route not available for {} to {}".format(token0_address, token1_address))
+
+    # get the cost required to convert tokens
+    cost = routes_functions[token1_address]['costs'][token0_address]
+    tokens_required = cost * output_amount
+    if (tokens_balance := get_token_balance(token0_address, account.address)) < tokens_required:
+        logging.error("Need {} more tokens".format(tokens_required - tokens_balance))
+        return False
+
+    # call the buy function with amount or default to no args
+    call_function = routes_functions[token1_address]['functions'][token0_address]
+    approve_token_spending(account, token0_address, token1_address, tokens_required)
+    token1_contract = load_contract(token1_address, load_contract_abi(token1_address))
+    amount = to_token_decimals(output_amount, token1_contract.functions.decimals().call())
+    try:
+        tx = getattr(token1_contract.functions, call_function)(int(amount)).build_transaction({
+            "from": account.address,
+            "nonce": get_nonce(account.address)
+        })
+    except Web3ValidationError as e:
+        if 'positional arguments with type(s) `int`' in str(e):
+            for i in range(0, amount):
+                # cancel the rest of this loop if the gas price is too damn high
+                if get_beacon_gas_prices('rapid', beacon_gasnow_cache_seconds) > rapid_gas_fee_limit:
+                    logging.warning("Gas fees are too high")
+                    return None
+                try:
+                    tx = getattr(token1_contract.functions, call_function)().build_transaction({
+                        "from": account.address,
+                        "nonce": get_nonce(account.address)
+                    })
+                    success = broadcast_transaction(account, tx, True, attempts)
+                except Exception as e:
+                    if error := interpret_exception_message(e):
+                        logging.error(
+                            "{}. Failed to convert using {}".format(error, routes_functions[token1_address]['label']))
+                else:
+                    if success:
+                        logging.info("Called {}({}) from {}".format(
+                            call_function,
+                            amount,
+                            routes_functions[token1_address]['label']
+                        ))
+                    else:
+                        logging.warning("Failed to call {}({}) from {}".format(
+                            call_function,
+                            amount,
+                            routes_functions[token1_address]['label']
+                        ))
+                        return False
+        else:
+            raise Web3ValidationError(e)
+        return True
+    else:
+        try:
+            success = broadcast_transaction(account, tx, True, attempts)
+        except Exception as e:
+            if error := interpret_exception_message(e):
+                logging.error("{}. Failed to convert using {}".format(error, routes_functions[token1_address]['label']))
+            return False
+        else:
+            if success:
+                logging.info("Called {}({}) from {}".format(
+                    call_function,
+                    amount,
+                    routes_functions[token1_address]['label']
+                ))
+                return True
+            else:
+                logging.warning("Failed to call {}({}) from {}".format(
+                    call_function,
+                    amount,
+                    routes_functions[token1_address]['label']
+                ))
+                return False
+
+
+def convert_tokens_multi(account, multi_address, token0_address, token1_address, iterations, attempts=18):
+    # check if conversion route exists or is disabled
+    routes_functions = json.load(open('./data/routes.json'))
+    if token0_address not in routes_functions[multi_address]['functions'].keys():
+        raise Exception("Route not available for {} to {} in {}".format(token0_address, token1_address, multi_address))
+    elif routes_functions[multi_address]['functions'][token0_address][0] == '#':
+        raise Exception("Route is disabled for {} to {} in {}".format(token0_address, token1_address, multi_address))
+
+    # get the cost required to convert tokens
+    cost = routes_functions[multi_address]['costs'][token0_address]
+    tokens_cost = cost * iterations * routes_functions[multi_address]['mints']
+    # python is so stupid sometimes
+    try:
+        decimal_places = len(str(cost).split('.')[1])
+        decimal_places = decimal_places if decimal_places <= 15 else 15
+    except (AttributeError, IndexError):
+        tokens_required = tokens_cost
+    else:
+        tokens_required = float(round(tokens_cost, decimal_places))
+
+    # check if the wallet has enough tokens to convert
+    if tokens_required > (tokens_balance := get_token_balance(token0_address, account.address)):
+        logging.error("Need {} more tokens".format(tokens_required - tokens_balance))
+        return False
+    # approve the tokens required to convert and determine how many loops
+    approve_token_spending(account, token0_address, multi_address, tokens_required)
+    loops = math.floor(iterations / routes_functions[multi_address]['max_iterations'])
+    if iterations % routes_functions[multi_address]['max_iterations'] != 0:
+        loops += 1
+    # start calling multi mints
+    for i in list(range(0, loops)):
+        # cancel the rest of this loop if the gas price is too damn high
+        if get_beacon_gas_prices('rapid', beacon_gasnow_cache_seconds) > rapid_gas_fee_limit:
+            logging.warning("Gas fees are too high")
+            return None
+        if i + 1 < loops or iterations == routes_functions[multi_address]['max_iterations']:
+            # do max iterations during loop
+            call_iterations = routes_functions[multi_address]['max_iterations']
+        else:
+            # on final loop run the remaining iterations
+            call_iterations = iterations % routes_functions[multi_address]['max_iterations']
+        # call the multi mint function with iterations based on tokens minted
+        call_function = routes_functions[multi_address]['functions'][token0_address]
+        multi_contract = load_contract(multi_address, load_contract_abi(multi_address))
+        try:
+            tx = getattr(multi_contract.functions, call_function)(call_iterations).build_transaction({
+                "from": account.address,
+                "nonce": get_nonce(account.address)
+            })
+            success = broadcast_transaction(account, tx, True, attempts)
+        except Exception as e:
+            if error := interpret_exception_message(e):
+                logging.error("{}. Failed to convert using {}".format(error, routes_functions[multi_address]['label']))
+        else:
+            if success:
+                logging.info("Called {}({}) from {}".format(
+                    call_function,
+                    call_iterations,
+                    routes_functions[multi_address]['label']
+                ))
+            else:
+                logging.warning("Failed to call {}({}) from {}".format(
+                    call_function,
+                    call_iterations,
+                    routes_functions[multi_address]['label']
+                ))
+                return False
+    return True
+
+
+def log_end_loop(delay):
+    if delay:
+        logging.info("Waiting for {} seconds...".format(delay))
+        time.sleep(delay)
+    logging.info("-" * 50)
+
+
+def estimate_swap_result(router_name, token0_address, token1_address, token0_amount, attempts=18):
+    routers = json.load(open('./data/routers.json'))
+    router_contract = load_contract(routers[router_name][0], routers[router_name][1])
+    token0_info = get_token_info(token0_address)
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            expected_output_amounts = router_contract.functions.getAmountsOut(
+                int(token0_amount * 10 ** token0_info['decimals']),
+                [token0_address, token1_address]
+            ).call()
+        except Exception as e:
+            logging.debug(e)
+            _attempts -= 1
+        else:
+            return expected_output_amounts
+    return []
+
+
+def interpret_exception_message(e):
+    logging.debug(e)
+    if 'insufficient funds for gas * price + value' in str(e):
+        return 'Not enough PLS'
+    elif 'transfer amount exceeds balance' in str(e):
+        return 'Not enough tokens'
+    return e
+
+
+def from_token_decimals(amount, decimals):
+    return amount / 10 ** decimals
+
+
+def generate_wallet(amount):
+    addresses = []
+    for i in list(range(0, amount)):
+        account = Web3().eth.account.create()
+        keystore = Web3().eth.account.encrypt(account.key.hex(), os.getenv('SECRET'))
+        folder = "./data/wallets/{}".format(account.address)
+        os.makedirs("data/wallets", exist_ok=True)
+        os.makedirs(folder, exist_ok=True)
+        open("{}/keystore".format(folder), 'w').write(json.dumps(keystore, indent=4))
+        addresses.append(account)
+    return addresses
+
+
+def get_abi_from_blockscout(address, attempts=18):
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            r = requests.get("https://api.scan.pulsechain.com/api/v2/smart-contracts/{}".format(address))
+            r.raise_for_status()
+        except RequestException:
+            _attempts -= 1
+            if _attempts > 0:
+                time.sleep(1)
+                continue
+            else:
+                raise RequestException
+        else:
+            resp = r.json()
+            if 'abi' in resp.keys():
+                return resp['abi']
+            else:
+                return []
+
+
+def get_average_gas_prices(average='median', tx_amount=100):
+    latest_block = web3.eth.get_block('latest')['number']
+    gas_limit = []
+    gas_prices = []
+    for block_number in range(latest_block, latest_block - tx_amount, -1):
+        try:
+            block = web3.eth.get_block(block_number, full_transactions=True)
+        except BlockNotFound:
+            continue
+        for _tx in block['transactions']:
+            gas_limit.append(_tx['gas'])
+            gas_prices.append(_tx['gasPrice'])
+        if len(gas_prices) >= tx_amount:
+            break
+    match average:
+        case 'mean':
+            average_gas_limit = mean(gas_limit[:tx_amount])
+            average_gas_price = mean(gas_prices[:tx_amount])
+        case 'median':
+            average_gas_limit = median(gas_limit[:tx_amount])
+            average_gas_price = median(gas_prices[:tx_amount])
+        case 'mode':
+            average_gas_limit = mode(gas_limit[:tx_amount])
+            average_gas_price = mode(gas_prices[:tx_amount])
+        case _:
+            return None
+    return {
+        "gas_limit": average_gas_limit,
+        "gas_price": average_gas_price
+    }
+
+
+def get_beacon_gas_prices(speed=None, cache_interval_seconds=5):
+    speeds = ('rapid', 'fast', 'standard', 'slow',)
+    os.makedirs(cache_folder := './data/cache/', exist_ok=True)
+    gas = {}
+    if os.path.isfile(gasnow_file := "{}/gasnow.json".format(cache_folder)):
+        gas = json.load(open(gasnow_file))
+    if not gas or gas['data']['timestamp'] + cache_interval_seconds < time.time():
+        try:
+            r = requests.get('https://beacon.pulsechain.com/api/v1/execution/gasnow')
+            gas = r.json()
+        except Exception as e:
+            if not gas:
+                logging.debug(e)
+                return None
+        else:
+            if not gas:
+                logging.debug("No gas data returned from GasNow API endpoint")
+                return None
+            else:
+                open('./data/cache/gasnow.json', 'w').write(json.dumps(gas, indent=4))
+    if type(speed) is str:
+        try:
+            return float(web3.from_wei(gas['data'][speed], 'gwei'))
+        except KeyError:
+            raise KeyError("No such speed as '{}' in gas price data {}".format(speed, list(speeds)))
+    return {speed:float(web3.from_wei(price, 'gwei')) for speed,price in gas['data'].items() if speed in speeds}
+
+
+def get_last_block_base_fee():
+    latest_block = web3.eth.get_block('latest')
+    base_fee = latest_block['baseFeePerGas']
+    return float(round(web3.from_wei(base_fee, 'gwei'), 2))
+
+
+def get_pls_balance(address, decimals=False):
+    balance = web3.eth.get_balance(address)
+    if decimals:
+        return balance
+    else:
+        return from_token_decimals(balance, 18)
+
+
+def get_nonce(address):
+    return web3.eth.get_transaction_count(web3.to_checksum_address(address))
+
+
+def get_token_balance(token_address, wallet_address, decimals=False):
+    token_contract = load_contract(token_address)
+    token_info = get_token_info(token_address)
+    token_balance = token_contract.functions.balanceOf(wallet_address).call()
+    if decimals:
+        return float(round(token_balance, 15))
+    else:
+        return float(round(from_token_decimals(token_balance, token_info['decimals']), 15))
+
+
+def get_token_info(token_address, attempts=18):
+    os.makedirs(token_folder := "./data/tokens".format(token_address), exist_ok=True)
+    token_info_file = "{}/{}.json".format(token_folder, token_address)
+    if os.path.isfile(token_info_file):
+        token_info = json.load(open(token_info_file))
+        if token_info['decimals'] is not None:
+            return token_info
+    token_name, token_symbol, token_decimals = None, None, None
+    token_contract = load_contract(token_address)
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            token_name = token_contract.functions.name().call()
+        except Web3Exception:
+            _attempts -= 1
+            continue
+        else:
+            break
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            token_symbol = token_contract.functions.symbol().call()
+        except Web3Exception:
+            _attempts -= 1
+            continue
+        else:
+            break
+    _attempts = attempts
+    while _attempts > 0:
+        try:
+            token_decimals = token_contract.functions.decimals().call()
+        except Web3Exception:
+            _attempts -= 1
+            continue
+        else:
+            break
+    token_info = {"name": token_name, "symbol": token_symbol, "decimals": token_decimals}
+    open(token_info_file, 'w').write(json.dumps(token_info, indent=4))
+    return token_info
+
+
+def load_contract(address, abi=None):
+    if not abi:
+        abi = load_contract_abi(address)
+    if not abi:
+        abi = json.load(open('./data/abi/ERC20.json'))
+    return web3.eth.contract(address=address, abi=abi)
+
+
+def load_contract_abi(address):
+    try:
+        abi = json.load(open("./data/abi/{}.json".format(address)))
+    except FileNotFoundError:
+        try:
+            abi = get_abi_from_blockscout(address)
+        except Exception as e:
+            logging.debug(e)
+            raise FileNotFoundError("Download a copy of the abi from Blockscout to this folder")
+        else:
+            if abi:
+                open("./data/abi/{}.json".format(address), 'w').write(json.dumps(abi, indent=4))
+            else:
+                raise FileNotFoundError("No abi found for this contract")
+    return abi
+
+
+def load_wallet(address, secret):
+    file_path = "./data/wallets/{}/keystore".format(address)
+    if not os.path.exists(file_path):
+        raise FileNotFoundError
+    keystore = "\n".join([line.strip() for line in open(file_path, 'r+')])
+    private_key = web3.eth.account.decrypt(keystore, secret)
+    return web3.eth.account.from_key(private_key)
+
+
+def mint_tokens(account, token_address, amount, attempts=18):
+    rng_functions = json.load(open('./data/rng.json'))
+    if token_address not in rng_functions:
+        raise Exception("Mint/RNG function not available for {}".format(token_address))
+    call_function = random.choice(list(rng_functions[token_address]['functions']))
+    token_contract = load_contract(token_address, load_contract_abi(token_address))
+    token_info = get_token_info(token_address)
+    for i in list(range(0, int(amount))):
+        tx = getattr(token_contract.functions, call_function)().build_transaction({
+            "from": account.address,
+            "nonce": get_nonce(account.address)
+        })
+        try:
+            success = broadcast_transaction(account, tx, False, attempts)
+        except Exception as e:
+            if error := interpret_exception_message(e):
+                logging.error("{} to mint {}".format(error, rng_functions[token_address]['label']))
+            return False
+        else:
+            if success:
+                logging.info("Called mint function for {} ({})".format(token_info['name'], token_info['symbol']))
+            else:
+                logging.warning(
+                    "Failed to call mint function for {} ({})".format(token_info['name'], token_info['symbol']))
+                return False
+    return True
+
+
+def sample_exchange_rate(router_name, token_address, quote_address, attempts=18):
+    _attempts = attempts
+    while _attempts > 0:
+        token_result = estimate_swap_result(router_name, token_address, quote_address, 1)
+        if len(token_result) == 0:
+            _attempts -= 1
+            time.sleep(1)
+            continue
+        else:
+            return token_result[1]
+    return None
+
+
+def send_pls(account, to_address, amount, attempts=18):
+    tx = {
+        'nonce': get_nonce(account.address),
+        'from': account.address,
+        'to': to_address,
+        'value': to_token_decimals(amount, 18),
+    }
+    try:
+        return broadcast_transaction(account, tx, False, attempts)
+    except Exception as e:
+        if error := interpret_exception_message(e):
+            logging.error("{}. Could not send to {}".format(error, to_address))
+        return False
+
+
+def send_tokens(account, token_address, to_address, amount, attempts=18):
+    token_contract = load_contract(token_address)
+    token_info = get_token_info(token_address)
+    try:
+        tx = token_contract.functions.transfer(
+            to_address,
+            to_token_decimals(amount, token_info['decimals'])
+        ).build_transaction({
+            'nonce': get_nonce(account.address),
+            'from': account.address
+        })
+        return broadcast_transaction(account, tx, False, attempts)
+    except Exception as e:
+        if error := interpret_exception_message(e):
+            logging.error("{}. Could not send {} ({}) to {}".format(
+                error,
+                token_info['name'],
+                token_info['symbol'],
+                to_address
+            ))
+        return False
+
+
+def set_logging(filename='app', level='INFO', backup_count=7):
+    if hasattr(logging, level.upper()):
+        os.makedirs('./data/logs/', exist_ok=True)
+        logging.basicConfig(
+            format='%(asctime)s %(name)s %(levelname)s %(message)s',
+            datefmt='%H:%M:%S',
+            level=getattr(logging, level.upper()),
+            handlers=[
+                TimedRotatingFileHandler(
+                    "./data/logs/{}.log".format(filename),
+                    when="midnight",
+                    interval=1,
+                    backupCount=backup_count
+                ),
+                logging.StreamHandler(sys.stdout)
+            ]
+        )
+        return True
+    raise Exception("Invalid logging level")
+
+
+def swap_tokens(account, router_name, token_route, estimated_swap_result, slippage_percent, taxed=False, attempts=18):
+    routers = json.load(open('./data/routers.json'))
+    router_contract = load_contract(routers[router_name][0], routers[router_name][1])
+    approve_token_spending(account, token_route[0], routers[router_name][0], estimated_swap_result[0])
+    if token_route[-1] == "0xA1077a294dDE1B09bB078844df40758a5D0f9a27":
+        tx = router_contract.functions.swapExactTokensForETH(
+            estimated_swap_result[0],
+            estimated_swap_result[1] - round(estimated_swap_result[1] * (slippage_percent / 100)),
+            token_route,
+            account.address,
+            int(time.time()) + (60 * 3)
+        )
+        tx_params = {
+            "from": account.address,
+            "nonce": get_nonce(account.address)
+        }
+    elif token_route[0] == "0xA1077a294dDE1B09bB078844df40758a5D0f9a27":
+        if taxed:
+            swap_function = router_contract.functions.swapExactETHForTokensSupportingFeeOnTransferTokens
+        else:
+            swap_function = router_contract.functions.swapExactETHForTokens
+        tx = swap_function(
+            0,
+            token_route,
+            account.address,
+            int(time.time()) + (60 * 3)
+        )
+        tx_params = {
+            "from": account.address,
+            "nonce": get_nonce(account.address),
+            "value": estimated_swap_result[0]
+        }
+    else:
+        if taxed:
+            swap_function = router_contract.functions.swapExactTokensForETHSupportingFeeOnTransferTokens
+        else:
+            swap_function = router_contract.functions.swapExactTokensForETH
+        tx = swap_function(
+            estimated_swap_result[0],
+            estimated_swap_result[1] - (estimated_swap_result[1] * slippage_percent),
+            token_route,
+            account.address,
+            int(time.time()) + (60 * 3)
+        )
+        tx_params = {
+            "from": account.address,
+            "nonce": get_nonce(account.address)
+        }
+    try:
+        tx = tx.build_transaction(tx_params)
+        return broadcast_transaction(account, tx, True, attempts)
+    except Exception as e:
+        if error := interpret_exception_message(e):
+            logging.error("{}. Failed to swap".format(error))
+        return False
+
+
+def to_token_decimals(amount, decimals):
+    amount = str(amount)
+    if '.' in amount:
+        decimals -= len(str(amount).split('.')[1])
+    return int(str(amount).replace('.', '') + '0' * decimals)
+
+
+def wrap_pls(account, amount, attempts=18):
+    wpls_contract = load_contract("0xA1077a294dDE1B09bB078844df40758a5D0f9a27")
+    tx = wpls_contract.functions.deposit().build_transaction({
+        "from": account.address,
+        "nonce": get_nonce(account.address),
+        "value": to_token_decimals(amount, 18)
+    })
+    try:
+        return broadcast_transaction(account, tx, True, attempts)
+    except Exception as e:
+        if error := interpret_exception_message(e):
+            logging.error("{} to wrap PLS".format(error))
+        return False
+
+
+def unwrap_pls(account, amount, attempts=18):
+    wpls_contract = load_contract("0xA1077a294dDE1B09bB078844df40758a5D0f9a27")
+    tx = wpls_contract.functions.withdraw(to_token_decimals(amount, 18)).build_transaction({
+        "from": account.address,
+        "nonce": get_nonce(account.address)
+    })
+    try:
+        return broadcast_transaction(account, tx, True, attempts)
+    except Exception as e:
+        if error := interpret_exception_message(e):
+            logging.error("{} to unwrap PLS".format(error))
+        return False

data/abi/0x17E136fD4c821ae25A611fAF187753B6e84736a4.json

@@ -0,0 +1,780 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "AvailableForPurchase",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Generate",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "View",
+        "outputs": [
+            {
+                "components": [
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Rod",
+                        "type": "tuple"
+                    },
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Cone",
+                        "type": "tuple"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Phi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Eta",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Mu",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Xi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Sigma",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Rho",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Upsilon",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Ohm",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Pi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omicron",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omega",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint8",
+                        "name": "Chi",
+                        "type": "uint8"
+                    }
+                ],
+                "internalType": "struct Dynamic.Faung",
+                "name": "",
+                "type": "tuple"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0x1dC5095D7Eca30cd856a6C22Da13f52bc3a14Db0.json

@@ -0,0 +1,121 @@
+[
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithDAI",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "newOwnerAddress",
+				"type": "address"
+			}
+		],
+		"name": "setOwner",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percent",
+				"type": "uint256"
+			}
+		],
+		"name": "setTax",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "tax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percentage",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "taxAmountByPercentage",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "taxMax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "tokenAddress",
+				"type": "address"
+			}
+		],
+		"name": "withdrawERC20",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "withdrawPLS",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	}
+]

data/abi/0x20c1DA6b3A2a3EA46a3c2CFeBB9Ac71E239d355A.json

@@ -0,0 +1,121 @@
+[
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithDAI",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "newOwneraddress",
+				"type": "address"
+			}
+		],
+		"name": "setOwner",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percent",
+				"type": "uint256"
+			}
+		],
+		"name": "setTax",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "tokenAddress",
+				"type": "address"
+			}
+		],
+		"name": "withdrawERC20",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "withdrawPLS",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "tax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percentage",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "taxAmountByPercentage",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "taxMax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]

data/abi/0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D.json

@@ -0,0 +1,857 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "What",
+                "type": "string"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint64",
+                "name": "Value",
+                "type": "uint64"
+            }
+        ],
+        "name": "DysnomiaNuclearEvent",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint64",
+                "name": "_a",
+                "type": "uint64"
+            }
+        ],
+        "name": "Alpha",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint64",
+                "name": "_b",
+                "type": "uint64"
+            }
+        ],
+        "name": "Beta",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithFa",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithFaung",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithMATH",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Generate",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "MotzkinPrime",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Pi",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Rho",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint64",
+                "name": "_a",
+                "type": "uint64"
+            },
+            {
+                "internalType": "bool",
+                "name": "Phi",
+                "type": "bool"
+            }
+        ],
+        "name": "Upsilon",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "View",
+        "outputs": [
+            {
+                "components": [
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Fa",
+                        "name": "Rod",
+                        "type": "tuple"
+                    },
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Fa",
+                        "name": "Cone",
+                        "type": "tuple"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Phi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Eta",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Mu",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Xi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Sigma",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Rho",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Upsilon",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Ohm",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Pi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omicron",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omega",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint8",
+                        "name": "Chi",
+                        "type": "uint8"
+                    }
+                ],
+                "internalType": "struct Faung",
+                "name": "",
+                "type": "tuple"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0x2b943Bf3cFc3B7A42DC7d13898171802BCD3Aea9.json

@@ -0,0 +1,780 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "AvailableForPurchase",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Generate",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "View",
+        "outputs": [
+            {
+                "components": [
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Rod",
+                        "type": "tuple"
+                    },
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Cone",
+                        "type": "tuple"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Phi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Eta",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Mu",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Xi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Sigma",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Rho",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Upsilon",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Ohm",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Pi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omicron",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omega",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint8",
+                        "name": "Chi",
+                        "type": "uint8"
+                    }
+                ],
+                "internalType": "struct Dynamic.Faung",
+                "name": "",
+                "type": "tuple"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0x2fc636E7fDF9f3E8d61033103052079781a6e7D2.json

@@ -0,0 +1,381 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "subtractedValue",
+                "type": "uint256"
+            }
+        ],
+        "name": "decreaseAllowance",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "addedValue",
+                "type": "uint256"
+            }
+        ],
+        "name": "increaseAllowance",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0x5092aE511259E69e7D184fE69f4603108c143feF.json

@@ -0,0 +1,121 @@
+[
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithDAI",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "newOwnerAddress",
+				"type": "address"
+			}
+		],
+		"name": "setOwner",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percent",
+				"type": "uint256"
+			}
+		],
+		"name": "setTax",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "tax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percentage",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "taxAmountByPercentage",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "taxMax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "tokenAddress",
+				"type": "address"
+			}
+		],
+		"name": "withdrawERC20",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "withdrawPLS",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	}
+]

data/abi/0x5EF3011243B03f817223A19f277638397048A0DC.json

@@ -0,0 +1,593 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "MotzkinPrime",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Random",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "a",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "b",
+                "type": "address"
+            }
+        ],
+        "name": "hashWith",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "hash",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "pure",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "_b",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_e",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_m",
+                "type": "uint256"
+            }
+        ],
+        "name": "modExp",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "result",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint64",
+                "name": "_b",
+                "type": "uint64"
+            },
+            {
+                "internalType": "uint64",
+                "name": "_e",
+                "type": "uint64"
+            },
+            {
+                "internalType": "uint64",
+                "name": "_m",
+                "type": "uint64"
+            }
+        ],
+        "name": "modExp64",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "result",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0x6B175474E89094C44Da98b954EedeAC495271d0F.json

@@ -0,0 +1,563 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "chainId_",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "guy",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": true,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes4",
+                "name": "sig",
+                "type": "bytes4"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "arg1",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "arg2",
+                "type": "bytes32"
+            },
+            {
+                "indexed": false,
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "LogNote",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "DOMAIN_SEPARATOR",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "PERMIT_TYPEHASH",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "guy",
+                "type": "address"
+            }
+        ],
+        "name": "deny",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "mint",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "move",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "nonces",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "holder",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "nonce",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "expiry",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bool",
+                "name": "allowed",
+                "type": "bool"
+            },
+            {
+                "internalType": "uint8",
+                "name": "v",
+                "type": "uint8"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "r",
+                "type": "bytes32"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "s",
+                "type": "bytes32"
+            }
+        ],
+        "name": "permit",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "pull",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "usr",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "push",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "guy",
+                "type": "address"
+            }
+        ],
+        "name": "rely",
+        "outputs": [],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "version",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "wards",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    }
+]

data/abi/0x79474ff39B0F9Dc7d5F7209736C2a6913cf50F82.json

@@ -0,0 +1,147 @@
+[
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithG5",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithMATH",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithPI",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "newOwneraddress",
+				"type": "address"
+			}
+		],
+		"name": "setOwner",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percent",
+				"type": "uint256"
+			}
+		],
+		"name": "setTax",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "tokenAddress",
+				"type": "address"
+			}
+		],
+		"name": "withdrawERC20",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "withdrawPLS",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "tax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percentage",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "taxAmountByPercentage",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "taxMax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]

data/abi/0x98375dA84C1493767De695Ee7Eef0BB522380A07.json

@@ -0,0 +1,134 @@
+[
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithDAI",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "iterations",
+				"type": "uint256"
+			}
+		],
+		"name": "multiBuyWithUSDC",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "newOwnerAddress",
+				"type": "address"
+			}
+		],
+		"name": "setOwner",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percent",
+				"type": "uint256"
+			}
+		],
+		"name": "setTax",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "tokenAddress",
+				"type": "address"
+			}
+		],
+		"name": "withdrawERC20",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "withdrawPLS",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "tax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "percentage",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "taxAmountByPercentage",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "taxMax",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]

data/abi/0xA1077a294dDE1B09bB078844df40758a5D0f9a27.json

@@ -0,0 +1,275 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "guy",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "deposit",
+        "outputs": [],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "withdraw",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "guy",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Deposit",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "dst",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "src",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "wad",
+                "type": "uint256"
+            }
+        ],
+        "name": "Withdrawal",
+        "type": "event"
+    },
+    {
+        "type": "receive"
+    }
+]

data/abi/0xA2262D7728C689526693aE893D0fD8a352C7073C.json

@@ -0,0 +1,381 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "subtractedValue",
+                "type": "uint256"
+            }
+        ],
+        "name": "decreaseAllowance",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "addedValue",
+                "type": "uint256"
+            }
+        ],
+        "name": "increaseAllowance",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0xB680F0cc810317933F234f67EB6A9E923407f05D.json

@@ -0,0 +1,606 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithMATH",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "MotzkinPrime",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Random",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "a",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "b",
+                "type": "address"
+            }
+        ],
+        "name": "hashWith",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "hash",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "pure",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "_b",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_e",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_m",
+                "type": "uint256"
+            }
+        ],
+        "name": "modExp",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "result",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint64",
+                "name": "_b",
+                "type": "uint64"
+            },
+            {
+                "internalType": "uint64",
+                "name": "_e",
+                "type": "uint64"
+            },
+            {
+                "internalType": "uint64",
+                "name": "_m",
+                "type": "uint64"
+            }
+        ],
+        "name": "modExp64",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "result",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/0xa96BcbeD7F01de6CEEd14fC86d90F21a36dE2143.json

@@ -0,0 +1,780 @@
+[
+    {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "allowance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientAllowance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "balance",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256",
+                "name": "needed",
+                "type": "uint256"
+            }
+        ],
+        "name": "ERC20InsufficientBalance",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "approver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidApprover",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "receiver",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidReceiver",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "sender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "ERC20InvalidSpender",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableInvalidOwner",
+        "type": "error"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "OwnableUnauthorizedAccount",
+        "type": "error"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "previousOwner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "AvailableForPurchase",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithDAI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithG5",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithPI",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDC",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint32",
+                "name": "amount",
+                "type": "uint32"
+            }
+        ],
+        "name": "BuyWithUSDT",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "Generate",
+        "outputs": [
+            {
+                "internalType": "uint64",
+                "name": "",
+                "type": "uint64"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "View",
+        "outputs": [
+            {
+                "components": [
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Rod",
+                        "type": "tuple"
+                    },
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint64",
+                                "name": "Base",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Secret",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Signal",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Channel",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Pole",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Identity",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Foundation",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Element",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Dynamo",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Manifold",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Ring",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Barn",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Coordinate",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Tau",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Eta",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Kappa",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint64",
+                                "name": "Alpha",
+                                "type": "uint64"
+                            },
+                            {
+                                "internalType": "uint8",
+                                "name": "Nu",
+                                "type": "uint8"
+                            }
+                        ],
+                        "internalType": "struct Conjecture.Fa",
+                        "name": "Cone",
+                        "type": "tuple"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Phi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Eta",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Mu",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Xi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Sigma",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Rho",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Upsilon",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Ohm",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Pi",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omicron",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint64",
+                        "name": "Omega",
+                        "type": "uint64"
+                    },
+                    {
+                        "internalType": "uint8",
+                        "name": "Chi",
+                        "type": "uint8"
+                    }
+                ],
+                "internalType": "struct Dynamic.Faung",
+                "name": "",
+                "type": "tuple"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burn",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "account",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "burnFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounceOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "newOwner",
+                "type": "address"
+            }
+        ],
+        "name": "transferOwnership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

data/abi/ERC20.json

@@ -0,0 +1,222 @@
+[
+	{
+		"constant": true,
+		"inputs": [],
+		"name": "name",
+		"outputs": [
+			{
+				"name": "",
+				"type": "string"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"constant": false,
+		"inputs": [
+			{
+				"name": "_spender",
+				"type": "address"
+			},
+			{
+				"name": "_value",
+				"type": "uint256"
+			}
+		],
+		"name": "approve",
+		"outputs": [
+			{
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"payable": false,
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"constant": true,
+		"inputs": [],
+		"name": "totalSupply",
+		"outputs": [
+			{
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"constant": false,
+		"inputs": [
+			{
+				"name": "_from",
+				"type": "address"
+			},
+			{
+				"name": "_to",
+				"type": "address"
+			},
+			{
+				"name": "_value",
+				"type": "uint256"
+			}
+		],
+		"name": "transferFrom",
+		"outputs": [
+			{
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"payable": false,
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"constant": true,
+		"inputs": [],
+		"name": "decimals",
+		"outputs": [
+			{
+				"name": "",
+				"type": "uint8"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"constant": true,
+		"inputs": [
+			{
+				"name": "_owner",
+				"type": "address"
+			}
+		],
+		"name": "balanceOf",
+		"outputs": [
+			{
+				"name": "balance",
+				"type": "uint256"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"constant": true,
+		"inputs": [],
+		"name": "symbol",
+		"outputs": [
+			{
+				"name": "",
+				"type": "string"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"constant": false,
+		"inputs": [
+			{
+				"name": "_to",
+				"type": "address"
+			},
+			{
+				"name": "_value",
+				"type": "uint256"
+			}
+		],
+		"name": "transfer",
+		"outputs": [
+			{
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"payable": false,
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"constant": true,
+		"inputs": [
+			{
+				"name": "_owner",
+				"type": "address"
+			},
+			{
+				"name": "_spender",
+				"type": "address"
+			}
+		],
+		"name": "allowance",
+		"outputs": [
+			{
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"payable": false,
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"payable": true,
+		"stateMutability": "payable",
+		"type": "fallback"
+	},
+	{
+		"anonymous": false,
+		"inputs": [
+			{
+				"indexed": true,
+				"name": "owner",
+				"type": "address"
+			},
+			{
+				"indexed": true,
+				"name": "spender",
+				"type": "address"
+			},
+			{
+				"indexed": false,
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "Approval",
+		"type": "event"
+	},
+	{
+		"anonymous": false,
+		"inputs": [
+			{
+				"indexed": true,
+				"name": "from",
+				"type": "address"
+			},
+			{
+				"indexed": true,
+				"name": "to",
+				"type": "address"
+			},
+			{
+				"indexed": false,
+				"name": "value",
+				"type": "uint256"
+			}
+		],
+		"name": "Transfer",
+		"type": "event"
+	}
+]

data/abi/Uniswapv2_Router.json

@@ -0,0 +1,971 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_factory",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_WPLS",
+        "type": "address"
+      }
+    ],
+    "type": "constructor"
+  },
+  {
+    "inputs": [],
+    "name": "WPLS",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "tokenA",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "tokenB",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountADesired",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountBDesired",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountAMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountBMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "addLiquidity",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenDesired",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETHMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "addLiquidityETH",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountToken",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETH",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "factory",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveOut",
+        "type": "uint256"
+      }
+    ],
+    "name": "getAmountIn",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveOut",
+        "type": "uint256"
+      }
+    ],
+    "name": "getAmountOut",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      }
+    ],
+    "name": "getAmountsIn",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      }
+    ],
+    "name": "getAmountsOut",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "reserveB",
+        "type": "uint256"
+      }
+    ],
+    "name": "quote",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "tokenA",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "tokenB",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountAMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountBMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "removeLiquidity",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETHMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "removeLiquidityETH",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountToken",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETH",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETHMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "removeLiquidityETHSupportingFeeOnTransferTokens",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountETH",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETHMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bool",
+        "name": "approveMax",
+        "type": "bool"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "removeLiquidityETHWithPermit",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountToken",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETH",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountTokenMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountETHMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bool",
+        "name": "approveMax",
+        "type": "bool"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "removeLiquidityETHWithPermitSupportingFeeOnTransferTokens",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountETH",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "tokenA",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "tokenB",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "liquidity",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountAMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountBMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bool",
+        "name": "approveMax",
+        "type": "bool"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "removeLiquidityWithPermit",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapETHForExactTokens",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactETHForTokens",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactETHForTokensSupportingFeeOnTransferTokens",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactTokensForETH",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactTokensForETHSupportingFeeOnTransferTokens",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactTokensForTokens",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOutMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapExactTokensForTokensSupportingFeeOnTransferTokens",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountInMax",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapTokensForExactETH",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountInMax",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address[]",
+        "name": "path",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      }
+    ],
+    "name": "swapTokensForExactTokens",
+    "outputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "type": "receive"
+  }
+]

data/cache/gasnow.json

@@ -0,0 +1,12 @@
+{
+    "code": 200,
+    "data": {
+        "rapid": 185641987380031,
+        "fast": 168375000000000,
+        "standard": 167055747083542,
+        "slow": 167055747083542,
+        "timestamp": 1720532689957,
+        "price": 1,
+        "priceUSD": 0
+    }
+}

data/rng.json

@@ -0,0 +1,40 @@
+{
+  "0xa96BcbeD7F01de6CEEd14fC86d90F21a36dE2143": {
+    "functions": {
+      "Generate": null
+    },
+    "label": "RNG 1"
+  },
+  "0x2b943Bf3cFc3B7A42DC7d13898171802BCD3Aea9": {
+    "functions": {
+      "Generate": null
+    },
+    "label": "RNG 2"
+  },
+  "0x17E136fD4c821ae25A611fAF187753B6e84736a4": {
+    "functions": {
+      "Generate": null
+    },
+    "label": "RNG 3"
+  },
+  "0x5EF3011243B03f817223A19f277638397048A0DC": {
+    "functions": {
+      "Random": null
+    },
+    "label": "MATH v1.0"
+  },
+  "0xB680F0cc810317933F234f67EB6A9E923407f05D": {
+    "functions": {
+      "Random": null
+    },
+    "label": "MATH v1.1"
+  },
+  "0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D": {
+    "functions": {
+      "Generate": null,
+      "Pi": null,
+      "Rho": null
+    },
+    "label": "AFFECTION™"
+  }
+}

data/routes.json

@@ -0,0 +1,218 @@
+{
+  "0xA2262D7728C689526693aE893D0fD8a352C7073C": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 300,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 300,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 300
+    },
+    "label": "pINDEPENDENCE"
+  },
+  "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 5,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 5,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 5
+    },
+    "label": "GIMME FIVE"
+  },
+  "0xa96BcbeD7F01de6CEEd14fC86d90F21a36dE2143": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 1
+    },
+    "label": "RNG 1"
+  },
+  "0x2b943Bf3cFc3B7A42DC7d13898171802BCD3Aea9": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 1
+    },
+    "label": "RNG 2"
+  },
+  "0x17E136fD4c821ae25A611fAF187753B6e84736a4": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 1
+    },
+    "label": "RNG 3"
+  },
+  "0x5EF3011243B03f817223A19f277638397048A0DC": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0xB680F0cc810317933F234f67EB6A9E923407f05D": "BuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.25,
+      "0x5EF3011243B03f817223A19f277638397048A0DC": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.004716981132075472
+    },
+    "label": "MATH 1.0",
+    "mints": 1
+  },
+  "0xB680F0cc810317933F234f67EB6A9E923407f05D": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "BuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "BuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "BuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0x5EF3011243B03f817223A19f277638397048A0DC": "BuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.25,
+      "0x5EF3011243B03f817223A19f277638397048A0DC": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.004716981132075472
+    },
+    "label": "MATH 1.1"
+  },
+  "0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D": {
+    "functions": {
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "BuyWithG5",
+      "0xB680F0cc810317933F234f67EB6A9E923407f05D": "BuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "BuyWithPI"
+    },
+    "costs": {
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.2,
+      "0xB680F0cc810317933F234f67EB6A9E923407f05D": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.003333333333333333
+    },
+    "label": "AFFECTION™"
+  },
+  "0x20c1DA6b3A2a3EA46a3c2CFeBB9Ac71E239d355A": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "multiBuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "#multiBuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "#multiBuyWithUSDT"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 300,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 300,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 300
+    },
+    "label": "Multi PI",
+    "mints": null,
+    "max_iterations": 1000
+  },
+  "0x5092aE511259E69e7D184fE69f4603108c143feF": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "multiBuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "#multiBuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "#multiBuyWithUSDT"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 5,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 5,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 5
+    },
+    "label": "Multi G5",
+    "mints": null,
+    "max_iterations": 1000
+  },
+  "0x1dC5095D7Eca30cd856a6C22Da13f52bc3a14Db0": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "multiBuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "multiBuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "#multiBuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "#multiBuyWithG5",
+      "0x5EF3011243B03f817223A19f277638397048A0DC": "#multiBuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "#multiBuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.25,
+      "0x5EF3011243B03f817223A19f277638397048A0DC": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.004716981132075472
+    },
+    "label": "Multi MATH v1.0",
+    "mints": 1,
+    "max_iterations": 300
+  },
+  "0x98375dA84C1493767De695Ee7Eef0BB522380A07": {
+    "functions": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": "multiBuyWithDAI",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "multiBuyWithUSDC",
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": "#multiBuyWithUSDT",
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "#multiBuyWithG5",
+      "0x5EF3011243B03f817223A19f277638397048A0DC": "#multiBuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "#multiBuyWithPI"
+    },
+    "costs": {
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F": 1,
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 1,
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7": 1,
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.25,
+      "0x5EF3011243B03f817223A19f277638397048A0DC": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.004716981132075472
+    },
+    "label": "Multi MATH v1.1",
+    "mints": 1,
+    "max_iterations": 300
+  },
+  "0x79474ff39B0F9Dc7d5F7209736C2a6913cf50F82": {
+    "functions": {
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": "multiBuyWithG5",
+      "0xB680F0cc810317933F234f67EB6A9E923407f05D": "multiBuyWithMATH",
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": "multiBuyWithPI"
+    },
+    "costs": {
+      "0x2fc636E7fDF9f3E8d61033103052079781a6e7D2": 0.2,
+      "0xB680F0cc810317933F234f67EB6A9E923407f05D": 1,
+      "0xA2262D7728C689526693aE893D0fD8a352C7073C": 0.003333333333333334
+    },
+    "label": "Multi AFFECTION™",
+    "mints": 3,
+    "max_iterations": 300
+  }
+}

data/rpc_servers.json

@@ -0,0 +1,6 @@
+[
+  "https://rpc.pulsechain.com",
+  "https://rpc-pulsechain.g4mm4.io",
+  "https://pulsechain-rpc.publicnode.com",
+  "https://pulse.nownodes.io"
+]

data/tokens/0x24F0154C1dCe548AdF15da2098Fdd8B8A3B8151D.json

@@ -0,0 +1,5 @@
+{
+    "name": "AFFECTION\u2122",
+    "symbol": "\u24b6",
+    "decimals": 18
+}

data/tokens/0x2fc636E7fDF9f3E8d61033103052079781a6e7D2.json

@@ -0,0 +1,5 @@
+{
+    "name": "GIMME FIVE",
+    "symbol": "\u2464",
+    "decimals": 18
+}

data/tokens/0x6B175474E89094C44Da98b954EedeAC495271d0F.json

@@ -0,0 +1,5 @@
+{
+    "name": "Dai Stablecoin",
+    "symbol": "DAI",
+    "decimals": 18
+}

data/tokens/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48.json

@@ -0,0 +1,5 @@
+{
+    "name": "USD Coin",
+    "symbol": "USDC",
+    "decimals": 6
+}

data/tokens/0xA1077a294dDE1B09bB078844df40758a5D0f9a27.json

@@ -0,0 +1,5 @@
+{
+    "name": "Wrapped Pulse",
+    "symbol": "WPLS",
+    "decimals": 18
+}

data/tokens/0xA2262D7728C689526693aE893D0fD8a352C7073C.json

@@ -0,0 +1,5 @@
+{
+    "name": "pINDEPENDENCE",
+    "symbol": "\u24df",
+    "decimals": 18
+}

data/tokens/0xB680F0cc810317933F234f67EB6A9E923407f05D.json

@@ -0,0 +1,5 @@
+{
+    "name": "libAtropaMath v1.1",
+    "symbol": "MATH",
+    "decimals": 18
+}

generate-wallets.py

@@ -0,0 +1,86 @@
+from core import *
+
+# show help
+if 'help' == sys.argv[1].lower():
+    print("Generates 1 or more number of wallet keystores and optionally displays their private keys.\n")
+    print("Example Usage:")
+    command = "python {}".format(sys.argv[0])
+    examples = ['--create', '--create 1', '--create 1 --show-private-keys', '--show-private-keys 0x1234567891234567891234567891234567891234']
+    for e in examples:
+        print("{} {}".format(command, e))
+    sys.exit()
+
+# make sure you have a unique secrets
+secret = os.getenv('SECRET')
+if secret == 'changeme' or not secret:
+    print('Change your secret in .env')
+    sys.exit()
+
+# display private key arg to add to metamask/rabby
+if "--show-private-keys" in sys.argv:
+    public_key_index = sys.argv.index("--show-private-keys")
+    show_private_key = True
+elif "-s" in sys.argv:
+    public_key_index = sys.argv.index("-s")
+    show_private_key = True
+else:
+    public_key_index = None
+    show_private_key = False
+
+# create specified number of wallets arg
+if "--create" in sys.argv or "-c" in sys.argv:
+    if "--create" in sys.argv:
+        amount_index = sys.argv.index("--create")
+    else:
+        amount_index = sys.argv.index("-c")
+
+    try:
+        amount = sys.argv[amount_index + 1]
+    except IndexError:
+        arg = sys.argv[amount_index].split('=')
+        if len(arg) == 1 or not arg[1].isnumeric():
+            amount = 1
+        else:
+            amount = arg[1]
+    if not str(amount).isnumeric():
+        print("Invalid amount")
+        sys.exit()
+    else:
+        amount = int(amount)
+else:
+    amount = 0
+
+# create new wallets
+if amount:
+    # generate X wallets based on sys.argv
+    wallets = generate_wallet(int(amount))
+    print("\nGenerated {} wallets\n".format(amount))
+    # display the generated wallet's keys
+    for wallet in wallets:
+        print("Public Key: {}".format(wallet.address))
+        if show_private_key:
+            print("Private Key: {}\n".format(wallet.key.hex()))
+
+# show private keys only
+elif show_private_key:
+    wallet_address = None
+    try:
+        wallet_address = sys.argv[public_key_index + 1]
+    except IndexError:
+        arg = sys.argv[public_key_index].split('=')
+        if len(arg) > 1:
+            wallet_address = arg[1]
+        else:
+            print("Not enough args")
+            sys.exit()
+
+    try:
+        wallet_address = web3.to_checksum_address(wallet_address)
+    except ValueError:
+        print("Invalid wallet address {}".format(wallet_address))
+    else:
+        print("\nPublic Key: {}".format(wallet_address))
+        wallet = load_wallet(wallet_address, secret)
+        print("Private Key: {}".format(wallet.key.hex()))
+        print("PLS Balance: {}".format(get_pls_balance(wallet_address)))
+        print()

requirements.txt

@@ -0,0 +1,4 @@
+python-dotenv
+web3
+web3_multi_provider
+requests

sample.env

@@ -0,0 +1,9 @@
+SECRET=changeme
+
+GAS_MULTIPLIER=2
+GAS_FEE_RAPID_LIMIT=650000
+BEACON_GASNOW_CACHE_SECONDS=3
+
+WALLET_A_ADDRESS=
+WALLET_B_ADDRESS=
+WALLET_C_ADDRESS=