abstract-solana 0.0.0.1__py3-none-any.whl

abstract_solana/__init__.py

@@ -0,0 +1,8 @@
+from .account_key_utils import *
+from .genesis_functions import *
+from .index_utils import *
+from .price_utils import *
+from .pubkey_utils import *
+from .signature_data_parse import *
+from .utils import *
+from .log_message_functions import *

abstract_solana/account_key_utils.py

@@ -0,0 +1,20 @@
+from .signature_data_parse import get_account_keys_from_txn,get_read_only_addresses_from_txn,get_writable_addresses_from_txn
+from .pubkey_utils import get_pubkey
+from abstract_utilities import is_number
+
+def get_all_account_keys(txnData):
+  accountKeys=[]
+  accountKeys += get_account_keys_from_txn(txnData)
+  accountKeys += get_read_only_addresses_from_txn(txnData)
+  accountKeys += get_writable_addresses_from_txn(txnData)
+  return accountKeys
+
+def get_account_key(index,txnData):
+    accountKeys = get_all_account_keys(txnData)
+    if index is not None and accountKeys is not None and is_number(index) and len(accountKeys)>int(index):
+        return accountKeys[int(index)]
+
+def get_account_index(accountIndex,txnData):
+    for i,account in enumerate(get_all_account_keys(txnData)):
+        if get_pubkey(str(account)) == get_pubkey(str(accountIndex)):
+            return i

abstract_solana/genesis_functions.py

@@ -0,0 +1,14 @@
+from .signature_data_parse import get_error_message_from_txn,get_block_time_from_txn
+def get_errorless_txn_from_signature_array(signatureArray):
+    return [sig for sig in signatureArray if get_error_message_from_txn(sig) == None]
+def return_oldest_from_signature_array(signatureArray,errorless=False):
+    if errorless:
+        signatureArray = get_errorless_txn_from_signature_array(signatureArray)
+    if signatureArray and isinstance(signatureArray,list):
+        if get_block_time_from_txn(signatureArray[0])<get_block_time_from_txn(signatureArray[-1]):
+            return signatureArray[0].get('signature')
+        return signatureArray[-1].get('signature')
+def return_oldest_last_and_original_length_from_signature_array(signatureArray):
+    return {"oldest":return_oldest_from_signature_array(signatureArray),
+     "oldestValid":return_oldest_from_signature_array(signatureArray,errorless=True),
+     "length":len(signatureArray)}

abstract_solana/index_utils.py

@@ -0,0 +1,43 @@
+from typing import List, Dict, Any, Optional, Union
+from .pubkey_utils import try_pubkey
+from .account_key_utils import get_all_account_keys
+
+def search_for_index(data,index_number,key):
+    for index_data in data:
+        if str(index_data.get(key)) == str(index_number):
+            return index_data
+        
+def search_for_account_index(data,index_number):
+    return search_for_index(data,index_number,'accountIndex')
+
+def find_log_entry(needle: str, log_entries: List[str]) -> Optional[str]:
+    for log_entry in log_entries:
+        if needle in log_entry:
+            return log_entry
+    return None
+
+def extract_lp_initialization_log_entry_info_from_log_entry(lp_log_entry: str) -> Dict[str, Union[int, float]]:
+    lp_initialization_log_entry_info_start = lp_log_entry.find('{')
+    return json.loads(fix_relaxed_json_in_lp_log_entry(lp_log_entry[lp_initialization_log_entry_info_start:]))
+
+def fix_relaxed_json_in_lp_log_entry(relaxed_json: str) -> str:
+    return relaxed_json.replace(r'([{,])\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:', r'\1"\2":')
+
+def get_associations(event, txnData):
+    accountKeys = get_all_account_keys(txnData)
+    key_properties = {'associatedAccounts': ['accountIndex', 'accounts'], 'programId': ['programIdIndex']}
+    new_accounts = {k: None for k in key_properties}
+    for key, values in key_properties.items():
+        for value in values:
+            subjects = event.get(value)
+            if value in event and subjects is not None:
+                subjects = event.get(value)
+                if isinstance(subjects, list):
+                    event[key] = [convert_subject(sub, accountKeys) for sub in subjects]
+                else:
+                    event[key] = convert_subject(subjects, accountKeys)
+                    
+    return event
+
+def convert_subject(sub, accountKeys):
+    return sub if try_pubkey(sub) else accountKeys[int(sub)]

abstract_solana/log_message_functions.py

@@ -0,0 +1,89 @@
+from abstract_utilities import make_list
+import json,pprint
+from .signature_data_parse import get_log_messages_from_txn,get_instructions_from_txn,get_inner_instructions_from_txn
+from  .account_key_utils import get_all_account_keys
+def ifListGetSection(list_obj,i=0):
+    if list_obj and isinstance(list_obj,list) and len(list_obj)>i:
+        list_obj = list_obj[i]
+    return list_obj
+def get_logs_from_index(txnData,index=None):
+    if index is not None:
+        allLogs = get_log_messages_from_txn(txnData)
+        endLog = get_end_log_index(txnData,index)
+        return allLogs[index:endLog]
+def get_program_ids(txnData):
+    allLogs = get_log_messages_from_txn(txnData)
+    return [log.split(' ')[1] for log in allLogs if 'invoke' in log]
+def get_program_id_from_log(logs):
+    for log in make_list(logs):
+        if 'invoke' in log.lower():
+            return log.split(' ')[1]
+def get_stack_height_from_logs(logs):
+    for log in make_list(logs):
+        if 'invoke' in log.lower():
+            return int(log.split(' ')[-1][1:-1])
+def get_end_log_index(txnData,index):
+    allLogs = get_log_messages_from_txn(txnData)
+    i=0
+    for i,log in enumerate(allLogs[index+1:]):
+        if 'invoke' in log.lower():
+            return index+1+i
+    return len(allLogs)
+def get_for_program_ids_info(txnData):
+    allLogs = get_log_messages_from_txn(txnData)
+    return [{"programId":get_program_id_from_log(allLogs[i]),
+             "start":i,
+             "end":get_end_log_index(txnData,i),
+             'stackHeight':get_stack_height_from_logs(allLogs[i]),
+             'events':[event.split(':')[0] for event in get_log_events(get_logs_from_index(txnData,index=i))],
+             'logs':get_logs_from_index(txnData,index=i)
+             } for i in range(len(allLogs)) if 'invoke' in allLogs[i].lower()]
+def split_log_for_instruction(log):
+    return log.split('log:')[-1].split('Instruction:')[-1]
+def clean_split_string(string,delim=' '):
+    return delim.join([spl for spl in string.split(' ') if spl])
+def get_log_events(logs=None,index=None):
+    return [clean_split_string(split_log_for_instruction(log)) for log in logs if 'log:' in log.lower() or 'instruction:' in log.lower()]
+def get_instruction_accounts(instruction,txnData):
+    accounts = get_all_account_keys(txnData)
+    return [accounts[index] for index in instruction.get('accounts',[]) if index < len(accounts)]  
+def get_instruction_info(instruction,txnData,instruction_index=0):
+  
+    stack_height = instruction.get('stackHeight') or 1
+    accounts = instruction.get('accounts',[])
+    associatedAccounts = get_instruction_accounts(instruction,txnData)
+    instruction_info = {'instruction_index':instruction_index,'accounts':accounts,'associatedAccounts':associatedAccounts,'instructionStackHeight':stack_height}
+
+    instruction_info.update(get_for_program_ids_info(txnData)[instruction_index])
+    return instruction_info
+def process_instructions(instructions,txnData,start_index=1):
+    catalog = []
+    for i, inst in enumerate(instructions):
+        instruction_index = start_index-1 + i
+        instruction_info = get_instruction_info(inst,txnData,instruction_index)
+        catalog.append(instruction_info)
+    return catalog
+def get_instructions_catalog(txnData,printIt=False,saveIt=False):
+    instructions = get_instructions_from_txn(txnData)
+    outer_instructions_catalog = process_instructions(instructions,txnData)
+    inner_instructions = get_inner_instructions_from_txn(txnData)
+    if inner_instructions:
+        inner_instructions_catalog = process_instructions(inner_instructions,txnData,start_index=len(instructions))
+    complete_catalog =  outer_instructions_catalog+inner_instructions_catalog
+    if printIt:
+        pprint.pprint(complete_catalog)
+    if saveIt:
+        with open(saveIt, 'w') as f:
+            json.dump(complete_catalog, f, indent=4)
+    return complete_catalog
+
+def find_in_catalog(string,txnData,programId=None):
+    complete_catalog = get_instructions_catalog(txnData)
+    return [txn for txn in complete_catalog if [event for event in txn['events'] if string.lower() in event.lower()]]
+def findKeyValueIdInCatalog(key,value,txnData,programId=None):
+    complete_catalog = get_instructions_catalog(txnData)
+    if programId:
+        complete_catalog = findKeyValueIdInCatalog('programId',programId,txnData)
+    return [txn for txn in make_list(complete_catalog) if txn.get(key) == value]
+def find_account_in_catalog(account,catalog):
+    return ifListGetSection([txn for txn in make_list(catalog) if account in txn.get('associatedAccounts')])

abstract_solana/price_utils.py

@@ -0,0 +1,77 @@
+from .signature_data_parse import get_account_keys_from_txn,get_post_balances_from_txn,get_pre_balances_from_txn,get_post_token_balances_from_txn,get_pre_token_balances_from_txn
+from .account_key_utils import get_all_account_keys
+from abstract_utilities import exponential,get_any_value,update_dict_value,get_value_from_path,find_paths_to_key
+from abstract_solcatcher import *
+def get_amount_dict(amount,decimals=9):
+    if amount!= None:
+        if isinstance(amount,dict):
+            amount_dict = get_any_value(amount,'uiTokenAmount')
+            amount = get_any_value(amount_dict,'amount')
+            decimals = get_any_value(amount_dict,'decimals')
+        return exponential(amount,decimals,-1)
+def create_token_txns(txnData):
+    preBalances = get_pre_balances_from_txn(txnData)
+    postBalances = get_post_balances_from_txn(txnData)
+    account_keys = get_all_account_keys(txnData)
+    pre_post_balances = {"preTokenBalances":preTokenBalances,"postTokenBalances":postTokenBalances}
+    dont_use = []
+    all_txns = {"accounts":[],"owner":[],'Balance Before':[],"Balance After":[],"Change":[],"mint":[],"balanceIndexs":[]}
+    for key,tokenBalances in pre_post_balances.items():
+        for i,tokenBalance in enumerate(tokenBalances):
+            index = tokenBalance.get('accountIndex')
+            if index not in dont_use:
+                dont_use.append(index)
+                after = get_amount_dict(get_acct_index(postTokenBalances,index))
+                change = get_amount_dict(tokenBalance)
+                if after!=None and change !=None:
+                    before = after-change
+                    if i == 0:
+                        pre_change = change
+                        change = before
+                        before = pre_change
+                    all_txns["accounts"].append(account_keys[index])
+                    all_txns["owner"].append(tokenBalance.get('owner'))
+                    all_txns['Balance Before'].append(before)
+                    all_txns["Balance After"].append(after)
+                    all_txns["Change"].append(change)
+                    all_txns["mint"].append(tokenBalance.get('mint'))
+                    all_txns["balanceIndexs"].append(find_paths_to_key(signature_data, key)[0]+[i])
+    return all_txns
+def get_solana_balances(txnData):
+    balance = []
+    preBalances = get_pre_balances_from_txn(txnData)
+    postBalances = get_post_balances_from_txn(txnData)
+    account_keys = get_all_account_keys(txnData)
+    all_txns = {"accounts":[],'Balance Before':[],"Balance After":[],"Change":[]}
+    for i, amt in enumerate(preBalances):
+        before = exponential(amt, 9,-1)
+        after = exponential(postBalances[i], 9,-1)
+        address = account_keys[i]
+        change = after - before
+        all_txns['accounts'].append(address)
+        all_txns['Balance Before'].append(before)
+        all_txns['Balance After'].append(after)
+        all_txns['Change'].append(change)
+    return all_txns
+def get_balances(txnData):
+    balances = {"solana":{},"tokens":{}}
+    solanaTxns = get_solana_balances(txnData)
+    tokenTxns = create_token_txns(txnData)
+    for i,address in enumerate(solanaTxns["accounts"]):
+        balances["solana"][address]={"Balance Before":solanaTxns["Balance Before"][i],"Balance After":solanaTxns["Balance After"][i],"Change":solanaTxns["Change"][i]}
+    for i,address in enumerate(tokenTxns["accounts"]):
+        before = tokenTxns["Balance Before"][i]
+        after = tokenTxns["Balance After"][i]
+        change = after - before
+        balances["tokens"][address]={"Balance Before":before,"Balance After":after,"Change":change,"mint":tokenTxns["mint"][i],"owner":tokenTxns["owner"][i],"balanceIndex":tokenTxns["balanceIndexs"][i]}
+    return balances
+def update_balance_data(txnData):
+    balances = get_balances(txnData)
+    all_txns = create_token_txns(txnData)
+    for key,values in balances["tokens"].items():
+        path =values.get("balanceIndex")
+        tokenBalance = get_value_from_path(txnData,path)
+        tokenBalance.update({key:values.get(key) for key in ["Balance Before","Balance After","Change"]})
+        signature_data = update_dict_value(txnData, path, tokenBalance)
+    txnData['meta']['balances']=balances
+    return txnData

abstract_solana/pubkey_utils.py

@@ -0,0 +1,59 @@
+from solders.pubkey import Pubkey
+from solders.signature import Signature
+def get_pubString(obj):
+    return Pubkey.from_string(str(obj))
+
+def get_sigString(obj):
+    return Signature.from_string(str(obj))
+
+def is_sigkey(obj):
+    return isinstance(obj,Signature)
+
+def is_pubkey(obj):
+    return isinstance(obj,Pubkey)
+
+def get_pubBytes(obj):
+    return Pubkey.from_bytes(obj)
+
+def get_sigBytes(obj):
+    return Signature.from_bytes(obj)
+
+def try_pubkey(obj):
+    return is_pubkey(get_pubkey(obj))
+
+def try_sigkey(obj):
+    return is_sigkey(get_sigkey(obj))
+
+def get_pubkey(obj):
+    if is_pubkey(obj):
+        return obj
+    address = obj
+    if isinstance(obj,bytes):
+        pubkey = get_pubBytes(address)
+        if is_pubkey(pubkey):
+            return pubkey
+    if isinstance(obj,str):
+        try:
+            pubkey= get_pubString(obj)
+        except:
+            pubkey = obj
+        if is_pubkey(pubkey):
+            return pubkey
+    return obj
+
+def get_sigkey(obj):
+    if is_sigkey(obj):
+        return obj
+    signature = obj
+    if isinstance(signature,bytes):
+        sigKey = get_sigBytes(signature)
+        if is_sigkey(sigKey):
+            return sigKey
+    if isinstance(signature,str):
+        try:
+            sigKey= get_sigString(signature)
+        except:
+            sigKey = signature
+        if is_sigkey(sigKey):
+            return sigKey
+    return obj

abstract_solana/signature_data_parse.py

@@ -0,0 +1,57 @@
+from abstract_utilities import make_list,get_any_value
+def get_block_time_from_txn(txnData):
+    return int(get_any_value(txnData,'blockTime') or 0)
+
+def get_meta_from_txn(txnData):
+    return txnData.get('meta',{})
+
+def get_transaction_from_txn(txnData):
+    return txnData.get('transaction', {})
+
+def get_message_from_txn(txnData):
+    return get_transaction_from_txn(txnData).get('message', {})
+
+def get_addres_lookup_table_from_txn(txnData):
+    return get_message_from_txn(txnData).get('addressTableLookups', [])
+
+def get_account_keys_from_txn(txnData):
+    return get_message_from_txn(txnData).get('accountKeys', [])
+
+def get_loaded_addresses_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('loadedAddresses',{})
+
+def get_read_only_addresses_from_txn(txnData):
+    return get_any_value(txnData,'readonly') or []
+
+def get_writable_addresses_from_txn(txnData):
+    return get_any_value(txnData,'writable') or []
+
+def get_log_messages_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('logMessages',[])
+
+def get_error_message_from_txn(txnData):
+    return make_list(get_any_value(txnData,'err'))[0]
+
+def get_instructions_from_txn(txnData):
+    return get_message_from_txn(txnData).get('instructions',[])
+
+def get_inner_instructions_raw(txnData):
+    return get_meta_from_txn(txnData).get('innerInstructions',[{}])
+
+def get_inner_instructions_from_txn(txnData):
+    return get_inner_instructions_raw(txnData)[0].get('instructions',[])
+
+def get_post_token_balances_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('postTokenBalances', [])
+
+def get_pre_token_balances_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('preTokenBalances', [])
+
+def get_post_balances_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('postBalances', [])
+
+def get_pre_balances_from_txn(txnData):
+    return get_meta_from_txn(txnData).get('preBalances', [])
+
+def get_signatures_from_txn(txnData):
+    return txnData.get('signatures',{})

abstract_solana/utils.py

@@ -0,0 +1,12 @@
+def ifListGetSection(listObj,section=0):
+    if isinstance(listObj,list):
+        if len(listObj)>section:
+            return listObj[section]
+    return listObj
+def if_list_get_Part(obj,i=0):
+    if obj and isinstance(obj,list) and len(obj)>i:
+        obj = obj[i]
+    return obj
+def updateData(data,**kwargs):
+  data.update(kwargs)
+  return data

abstract_solana-0.0.0.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: abstract_solana
+Version: 0.0.0.1
+Home-page: https://github.com/AbstractEndeavors/abstract_solana
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: solders
+Requires-Dist: abstract-utilities
+
+## Abstract Solana
+
+

abstract_solana-0.0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+abstract_solana/__init__.py,sha256=1uasnh7qIFl4MqOKSbJF-9XM-vjBTBbya8PDayX3OsU,242
+abstract_solana/account_key_utils.py,sha256=VMJd4GOTK1vn8UZsfXDnjxDOGoQWGY6fvflJqPZ7Xvs,877
+abstract_solana/genesis_functions.py,sha256=2WRQUxN9j-dpLfYIBiX3URM-_uDGkh-eTy08Gi-qWgo,939
+abstract_solana/index_utils.py,sha256=Ed07BYTZWp-SVfpthAUqjRY00U3ZYldPCqd7LJy9AO8,1884
+abstract_solana/log_message_functions.py,sha256=SYBcqHEbbU6p_GGal3D2HwJK488dUIvEjuenrfKrd24,4564
+abstract_solana/price_utils.py,sha256=axIonTpdCe9zpoBD372FpwaPmqO8-oCslkdBJ29Uk2w,4246
+abstract_solana/pubkey_utils.py,sha256=gR3lvjTK3gAzD46D0_Ceq9o4kV2MGHKisyXqAHJduHY,1384
+abstract_solana/signature_data_parse.py,sha256=5AOMtJZADWcwR0JLDbd2kXZNzW129qeB0lvYUrE_tm0,1974
+abstract_solana/utils.py,sha256=Y1nyq-x7GqN09MEDrmiBM5iNDLJHDafFZ_lXrV0ua8k,348
+abstract_solana-0.0.0.1.dist-info/METADATA,sha256=7OOBXCNMjoFZ5ZEyZdwPnoq0I-G6yd2XBRy-8tsHR5Q,923
+abstract_solana-0.0.0.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+abstract_solana-0.0.0.1.dist-info/top_level.txt,sha256=SsJYent8eZQ0FU2jmP8wTj7aFZFhNwxxP-5cCTQ2B-o,16
+abstract_solana-0.0.0.1.dist-info/RECORD,,

abstract_solana-0.0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

abstract_solana-0.0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+abstract_solana