getsourcecode 2.1.0__py3-none-any.whl

getsourcecode/__init__.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+from getsourcecode.check import *
+from getsourcecode.filter import *
+from getsourcecode.config import *
+from getsourcecode.keys import *
+from getsourcecode.common import *
+import getsourcecode.menu
+import urllib3
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+# Load config
+parser = menu.argparse_menu()
+
+
+def get_code(input_file, output_folder, address, network, api_key):
+    try:
+        if network.lower() == "Tron".lower():
+            addresses = get_addresses_by_file_or_string(input_file, True, address)
+            send_tron(addresses, output_folder)
+        elif network.lower() == "okt" or network.lower() == "okt-testnet" or network.lower() == "okb":
+            if parser.apikey == "":
+                print_okex_api_key_explain()
+                return
+            addresses = get_addresses_by_file_or_string(input_file, False, address)
+            send_okex(addresses, output_folder, parser.apikey, network.lower())
+        elif network.lower() == "klaytn" or network.lower() == "baobab":
+            addresses = get_addresses_by_file_or_string(input_file, False, address)
+            send_klaytn(addresses, output_folder, network)
+        elif network.lower() == "ronin" or network.lower() == "ronin-testnet":
+            addresses = get_addresses_by_file_or_string(input_file, False, address)
+            send_ronin(addresses, output_folder, network)
+        elif network.lower() == "zksyncera" or network.lower() == "zksyncera-testnet":
+            addresses = get_addresses_by_file_or_string(input_file, False, address)
+            send_zksync_era(addresses, output_folder, network)
+        else:
+            if network in paid_only_set and api_key == "":
+                raise ValueError("Invalid api key, please privide paid api key")
+            addresses = get_addresses_by_file_or_string(input_file, False, address)
+            if addresses:
+                send_request(addresses, output_folder, network, api_key)
+            else:
+                raise ValueError("Error address")
+    except Exception as e:
+        handle_exception(e)
+
+
+def main():
+    try:
+        if parser.proxy:
+            set_configs(parser.proxy)
+        if parser.update:
+            check_update(name, current_version)
+            sys.exit(0)
+        elif parser.inputFile != "" or parser.address != "":
+            get_code(parser.inputFile, parser.outputFolder, parser.address, parser.network.lower(), parser.key)
+        elif parser.txhash != "":
+            get_addresses_by_tx(parser.txhash, parser.network.lower(), parser.outputFolder)
+        else:
+            print("Invalid command")
+        if contract_info != {}:
+            print("\nAddress => ContractName:")
+            for key in contract_info.keys():
+                print(f"{key}\t{contract_info[key]}")
+        if proxy_contract != {}:
+            print("\nProxy => Implementation:")
+            for key in proxy_contract.keys():
+                print(f"{key}\t{proxy_contract[key]}")
+        print('\nSuccess.')
+    except Exception as e:
+        handle_exception(e)
+
+
+if __name__ == '__main__':
+    main()

getsourcecode/check.py

@@ -0,0 +1,22 @@
+import requests
+import certifi
+from distutils.version import StrictVersion
+
+
+def check_update(package_name, current_version):
+    try:
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        response = requests.get(url, verify=False)
+        response.raise_for_status()
+        data = response.json()
+        latest_version = data["info"]["version"]
+        if StrictVersion(current_version) < StrictVersion(latest_version):
+            print(f"A new version of {package_name} is available: {latest_version}")
+        else:
+            print(f"You are using the latest version ({current_version}) of {package_name}.")
+    except requests.exceptions.RequestException as e:
+        print("Failed to check for updates:", str(e))
+    except KeyError:
+        print("Failed to parse response data.")
+    except Exception as e:
+        print("An error occurred:", str(e))

getsourcecode/common.py

@@ -0,0 +1,69 @@
+import sys
+import os
+import time
+import hashlib
+import traceback
+
+# Package base info
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36"
+current_version = "2.0.11"
+name = "getsourcecode"
+proxy_contract = {}
+contract_index = 0
+contract_info = {}
+EXIT_CODE = 0
+temp_contract_name = ""
+find_duplicate_file = False
+proxy = ""
+deal_addresses = []
+
+def print_okex_api_key_explain():
+    print("If you want to get the contract code of the okex link, you need to manually enter the api key.\nVisit this link: \n1. okt: https://www.oklink.com/cn/oktc/address/0x38AB5022BEa07AA8966A9bEB5EF7759b715e4BEE\n2. okb: https://www.oklink.com/cn/okbc-test/address/0x6BC26C28130e7634fFa1330969f34e98DC4d0019\n3. okt-testnet: https://www.oklink.com/cn/oktc-test/address/0x7c3ebCB6c4Ae99964980006C61d7eb032eDcb06B\n\nFollow the steps below:\n1. Open the above link\n2. Open the browser developer tool\n3. Click the contract tab page on the browser\n4. Find the request \"contract?t=\"\n5. X-Apikey in the request header of the request is the required apikey\n\nFor example:\ngetCode -p 127.0.0.1:7890 -n okt -a 0x38AB5022BEa07AA8966A9bEB5EF7759b715e4BEE --apikey LWIzMWUtNDU0Ny05Mjk5LWI2ZDA3Yjc2MzFhYmEyYzkwM2NjfDI4MDQzNDU3Mjc2NjY0OTI=")
+    sys.exit(EXIT_CODE)
+
+    
+def set_configs(input_proxy):
+    global proxy
+    proxy = input_proxy
+
+
+def get_proxies():
+    proxies = {}
+    if proxy != "":
+        proxies = {
+            "https": "http://" + proxy,
+            "http": "http://" + proxy
+        }
+    return proxies
+
+
+def handle_exception(e):
+    print("--------------------------------------")
+    traceback.print_exc()
+    print("--------------------------------------")
+    sys.exit(EXIT_CODE)
+
+def hash_file(file_path, algorithm='sha256'):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        text = f.read()
+    hash_result = hash_string(text, algorithm)
+    return hash_result
+
+def hash_string(text, algorithm='sha256'):
+    h = hashlib.new(algorithm)
+    h.update(text.encode('utf-8'))
+    return h.hexdigest()
+
+
+
+def make_dir(path):
+    path = path.strip()
+    path = path.rstrip("\\")
+    if not os.path.exists(path):
+        try:
+            os.makedirs(path)
+            return True
+        except OSError:
+            return False
+    else:
+        return False

getsourcecode/config.py

@@ -0,0 +1,175 @@
+class CaseInsensitiveDict(dict):
+    def __init__(self, data=None):
+        super().__init__()
+        if data:
+            for key, value in data.items():
+                self[key] = value  # 走重写的 __setitem__
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key.lower(), value)
+
+    def __getitem__(self, key):
+        return super().__getitem__(key.lower())
+
+    def __contains__(self, key):
+        return super().__contains__(key.lower())
+
+    def get(self, key, default=None):
+        return super().get(key.lower(), default)
+
+api_keys = [
+    "B69GNP1IXCXJUGTWVCZPW4PS6KFDQ9MNJ1",
+    "TRUHXX8K4D5E4665M22FUYZ6F4ZP4SC6UQ",
+    "373ZPPAM1QZYS55Q5AW24BKW124BGPMPIA",
+    "75FE5RHNXQJPRY6A4EGXTWJKE4M7783W6F",
+    "TRUHXX8K4D5E4665M22FUYZ6F4ZP4SC6UQ",
+    "Q8K1J5WIXHVQWV1XHVFF1INTPHWFZP5AZV",
+    "KWPEX5CZ437P2JRB2U7WZ37VQFAVZFXXP6"
+]
+
+req_url = "https://api.etherscan.io/v2/api?module=contract&action=getsourcecode&address="
+
+tx_hash_scan_config = {
+    'eth': {
+        "url": "https://etherscan.io/vmtrace?txhash={}&type=parity#raw",
+        "re": r"<preid=\"editor\"class=\"ms-3\">(.*?)</pre>"
+    },
+    'bsc': {
+        "url": "https://www.bscscan.com/vmtrace?txhash={}&type=gethtrace2",
+        "re": r"<preid=\"editor\"class=\"ms-3\">(.*?)</pre>"
+    },
+    'heco': {
+        "url": "https://www.hecoinfo.com/api/v1/chain/txs/detail?txHash={}&chainId=HECO",
+        "re": ""
+    },
+    'arbi': {
+        "url": "https://arbiscan.io/vmtrace?txhash={}&type=gethtrace2",
+        "re": r"<preid='editor'>(.*?)</pre>"
+    },
+    'boba': {
+        "url": "https://bobascan.com/vmtrace?txhash={}&type=gethtrace2",
+        "re": r"<preid='editor'>(.*?)</pre>"
+    },
+    'arbi-nova': {
+        "url": "https://nova.arbiscan.io/vmtrace?txhash={}&type=gethtrace2",
+        "re": r"<preid='editor'>(.*?)</pre>"
+    }
+}
+
+tenderly_chain_id_list = {
+    "arbi": 42161,
+    "arbi-testnet": 421613,
+    "bsc": 56,
+    "bsc-testnet": 97,
+    "avax": 43114,
+    "avax-testnet": 43113,
+    "fantom": 250,
+    "ftm-testnet": 25,
+    "moonbeam": 1284,
+    "moonriver": 1285,
+    "cronos": 25,
+    "cronos-testnet": 338,
+    "boba-testnet": 2888,
+    "gnosis": 100,
+    "eth": 1,
+    "sepolia": 11155111,
+    "goerli": 5,
+    "poly": 137,
+    "poly-testnet": 80001,
+    "opt": 10,
+    "opt-testnet": 420,
+    "base": 8453,
+    "base-testnet": 84531,
+    "boba": 288
+}
+
+special_trace_api = {
+    "klaytn": {},
+    'ronin': {}
+}
+
+chain_to_id = CaseInsensitiveDict({
+    "Ethereum Mainnet": 1,
+    "Sepolia Testnet": 11155111,
+    "Hoodi Testnet": 560048,
+    "BNB Smart Chain Mainnet": 56,
+    "BNB Smart Chain Testnet": 97,
+    "Polygon Mainnet": 137,
+    "Polygon Amoy Testnet": 80002,
+    "Base Mainnet": 8453,
+    "Base Sepolia Testnet": 84532,
+    "Arbitrum One Mainnet": 42161,
+    "Arbitrum Sepolia Testnet": 421614,
+    "Linea Mainnet": 59144,
+    "Linea Sepolia Testnet": 59141,
+    "Blast Mainnet": 81457,
+    "Blast Sepolia Testnet": 168587773,
+    "OP Mainnet": 10,
+    "OP Sepolia Testnet": 11155420,
+    "Avalanche C-Chain": 43114,
+    "Avalanche Fuji Testnet": 43113,
+    "BitTorrent Chain Mainnet": 199,
+    "BitTorrent Chain Testnet": 1029,
+    "Celo Mainnet": 42220,
+    "Celo Sepolia Testnet": 11142220,
+    "Fraxtal Mainnet": 252,
+    "Fraxtal Hoodi Testnet": 2523,
+    "Gnosis": 100,
+    "Mantle Mainnet": 5000,
+    "Mantle Sepolia Testnet": 5003,
+    "Memecore Mainnet": 4352,
+    "Memecore Testnet": 43521,
+    "Moonbeam Mainnet": 1284,
+    "Moonriver Mainnet": 1285,
+    "Moonbase Alpha Testnet": 1287,
+    "opBNB Mainnet": 204,
+    "opBNB Testnet": 5611,
+    "Scroll Mainnet": 534352,
+    "Scroll Sepolia Testnet": 534351,
+    "Taiko Mainnet": 167000,
+    "Taiko Hoodi": 167013,
+    "XDC Mainnet": 50,
+    "XDC Apothem Testnet": 51,
+    "ApeChain Mainnet": 33139,
+    "ApeChain Curtis Testnet": 33111,
+    "World Mainnet": 480,
+    "World Sepolia Testnet": 4801,
+    "Sonic Mainnet": 146,
+    "Sonic Testnet": 14601,
+    "Unichain Mainnet": 130,
+    "Unichain Sepolia Testnet": 1301,
+    "Abstract Mainnet": 2741,
+    "Abstract Sepolia Testnet": 11124,
+    "Berachain Mainnet": 80094,
+    "Berachain Bepolia Testnet": 80069,
+    "Swellchain Mainnet": 1923,
+    "Swellchain Testnet": 1924,
+    "Monad Mainnet": 143,
+    "Monad Testnet": 10143,
+    "HyperEVM Mainnet": 999,
+    "Katana Mainnet": 747474,
+    "Katana Bokuto": 737373,
+    "Sei Mainnet": 1329,
+    "Sei Testnet": 1328,
+    "Stable Mainnet": 988,
+    "Stable Testnet": 2201,
+    "Plasma Mainnet": 9745,
+    "Plasma Testnet": 9746,
+    "MegaETH Mainnet": 4326,
+    "MegaETH Testnet": 6342,
+})
+
+paid_only_chains = [
+    "BNB Smart Chain Mainnet",
+    "BNB Smart Chain Testnet",
+    "Base Mainnet",
+    "Base Sepolia Testnet",
+    "OP Mainnet",
+    "OP Sepolia Testnet",
+    "Avalanche C-Chain",
+    "Avalanche Fuji Testnet",
+]
+
+paid_only_set = {c.lower() for c in paid_only_chains}
+
+chain_id_to_name = {v: k for k, v in chain_to_id.items()}

getsourcecode/filter.py

@@ -0,0 +1,169 @@
+import re
+from getsourcecode.handle import *
+from getsourcecode.config import *
+from retrying import retry
+import certifi
+
+current_path = os.getcwd()
+ADDRESS_PATTERN = r'[\'\"]{1}[\s]{0,5}:[\s]{0,5}[\'\"]{1}(0x[a-zA-Z0-9)]{40})[\'\"]{1}'
+
+
+def get_address(json_data):
+    try:
+        address_list = list(set(re.findall(ADDRESS_PATTERN, json_data)))
+        return address_list
+    except Exception as e:
+        handle_exception(e)
+
+
+def read_file(file_path):
+    if os.path.isfile(file_path):
+        with open(file_path, 'r', encoding='utf-8') as fr:
+            return fr.read().replace('\n', ' ')
+    else:
+        raise FileNotFoundError("File not found: {}".format(file_path))
+
+
+def get_addresses_from_input(input_file, add_string):
+    if input_file:
+        file_path = os.path.join(current_path, input_file)
+        add_str = read_file(file_path)
+    elif add_string:
+        add_str = add_string
+    else:
+        return None
+    return add_str
+
+
+def get_addresses_by_file_or_string(input_file, is_tron, add_string,):
+    try:
+        add_str = get_addresses_from_input(input_file, add_string)
+        if add_str is None:
+            return None
+
+        if is_tron:
+            pattern = r'T[a-zA-Z\d]{33}'
+        else:
+            pattern = r'0x[a-zA-Z\d]{40}'
+
+        addresses = re.findall(pattern, add_str)
+        return addresses
+    except Exception as e:
+        handle_exception(e)
+
+
+@retry(stop_max_attempt_number=5, wait_fixed=2000)
+def get_by_tenderly_api_use_retry(tx_hash, proxies, network):
+    tenderly_api = f'https://api.tenderly.co/api/v1/public-contract/{tenderly_chain_id_list[network]}/tx/{tx_hash}'
+    tenderly_req = requests.get(tenderly_api, proxies=proxies, verify=False)
+    return tenderly_req.json()['addresses']
+
+
+@retry(stop_max_attempt_number=5, wait_fixed=2000)
+def get_by_scan_use_re_use_retry(url, proxies):
+    header = {
+        "User-Agent": USER_AGENT
+    }
+    scan_req = requests.get(url, headers=header, proxies=proxies, verify=False)
+    return scan_req
+
+
+def get_by_scan_use_re(tx_hash, proxies, network):
+    try:
+        url = tx_hash_scan_config[network]['url'].format(tx_hash)
+        scan_req = get_by_scan_use_re_use_retry(url, proxies)
+        if tx_hash_scan_config[network]['re'] != "":
+            data = scan_req.text.replace("\r\n", "").replace(' ', '').replace('\n', '')
+            result = re.findall(r"{}".format(tx_hash_scan_config[network]['re']), data)[0]
+        else:
+            result = "{}".format(scan_req.json()["data"]["overview"]["internalTxns"])
+        if network == 'eth':
+            result = "[" + result + "]"
+        scan_address_list = get_address(result)
+        return scan_address_list
+    except Exception as e:
+        handle_exception(e)
+
+
+@retry(stop_max_attempt_number=5, wait_fixed=2000)
+def get_ronin_info_by_api_use_retry(tx_hash, start_index, size, header, proxies):
+    ronin_api = f'https://explorerv3-api.roninchain.com/tx/{tx_hash}/internal?from={start_index}&size={size}'
+    ronin_req = requests.get(ronin_api, headers=header, proxies=proxies, verify=False)
+    return ronin_req
+
+
+def get_by_special_way_ronin(tx_hash, proxies):
+    special_way_ronin_address_list = []
+    header = {
+        "User-Agent": USER_AGENT,
+        "Content-Type": "application/json"
+    }
+    try:
+        start_index = 0
+        size = 25
+        while True:
+            ronin_req = get_ronin_info_by_api_use_retry(tx_hash, start_index, size, header, proxies)
+            for ronin_item in ronin_req.json()['results']:
+                special_way_ronin_address_list.append(ronin_item['from'])
+                special_way_ronin_address_list.append(ronin_item['to'])
+            total = ronin_req.json()["total"]
+            rest = total - (start_index + 1) * 25
+            if rest <= 0:
+                break
+            start_index = start_index + size
+        return special_way_ronin_address_list
+    except Exception as e:
+        handle_exception(e)
+
+
+@retry(stop_max_attempt_number=5, wait_fixed=2000)
+def get_klaytn_block_by_api_use_retry(tx_hash, proxies):
+    klaytn_block_api = f"https://api-cypress.klaytnscope.com/v2/txs/{tx_hash}"
+    klaytn_block_req = requests.get(klaytn_block_api, proxies=proxies, verify=False)
+    return klaytn_block_req.json()["result"]["blockNumber"]
+
+
+@retry(stop_max_attempt_number=5, wait_fixed=2000)
+def get_klaytn_trance_by_api_use_retry(tx_hash, proxies, klaytn_block):
+    klaytn_trance_api = f"https://api-cypress.klaytnscope.com/v2/blocks/{klaytn_block}/itxDetail?txHash={tx_hash}"
+    klaytn_trance_req = requests.get(klaytn_trance_api, proxies=proxies, verify=False)
+    return klaytn_trance_req
+
+
+def get_by_special_way_klaytn(tx_hash, proxies):
+    special_way_klaytn_address_list = []
+    try:
+        klaytn_block = get_klaytn_block_by_api_use_retry(tx_hash, proxies)
+        klaytn_trance_req = get_klaytn_trance_by_api_use_retry(tx_hash, proxies, klaytn_block)
+        for klaytn_item in klaytn_trance_req.json()["result"]:
+            special_way_klaytn_address_list.append(klaytn_item['fromAddress'])
+            special_way_klaytn_address_list.append(klaytn_item['toAddress'])
+        return special_way_klaytn_address_list
+    except Exception as e:
+        handle_exception(e)
+
+
+def get_by_special_way(tx_hash, proxies, network):
+    special_address_list = []
+    if network == "ronin":
+        special_address_list = get_by_special_way_ronin(tx_hash, proxies)
+    elif network == "klaytn":
+        special_address_list = get_by_special_way_klaytn(tx_hash, proxies)
+    return special_address_list
+
+
+def get_addresses_by_tx(tx_hash, network, output_folder):
+    temp_addresses_list = []
+    proxies = get_proxies()
+    if network in tenderly_chain_id_list.keys():
+        temp_addresses_list = get_by_tenderly_api_use_retry(tx_hash, proxies, network)
+    elif network in tx_hash_scan_config.keys():
+        temp_addresses_list = get_by_scan_use_re(tx_hash, proxies, network)
+    elif network in special_trace_api.keys():
+        temp_addresses_list = get_by_special_way(tx_hash, proxies, network)
+
+    if temp_addresses_list:
+        temp_addresses_list = list(set(temp_addresses_list))
+        send_request(temp_addresses_list, output_folder, network)
+    else:
+        print(f"{network} is not supported (at least for now).")