abstract-solana 0.0.0.1__tar.gz

abstract_solana-0.0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,3 @@
+## Abstract Solana
+
+

abstract_solana-0.0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abstract_solana-0.0.0.1/setup.py

@@ -0,0 +1,34 @@
+from time import time
+import setuptools
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+setuptools.setup(
+    name='abstract_solana',
+    version='0.0.0.01',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description="",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/AbstractEndeavors/abstract_solana',
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'Topic :: Software Development :: Libraries',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+    install_requires=['solders','abstract_utilities'],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.6",
+    # Add this line to include wheel format in your distribution
+    setup_requires=['wheel'],
+)

abstract_solana-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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-0.0.0.1/src/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/src/abstract_solana.egg-info/PKG-INFO

@@ -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/src/abstract_solana.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+src/abstract_solana/__init__.py
+src/abstract_solana/account_key_utils.py
+src/abstract_solana/genesis_functions.py
+src/abstract_solana/index_utils.py
+src/abstract_solana/log_message_functions.py
+src/abstract_solana/price_utils.py
+src/abstract_solana/pubkey_utils.py
+src/abstract_solana/signature_data_parse.py
+src/abstract_solana/utils.py
+src/abstract_solana.egg-info/PKG-INFO
+src/abstract_solana.egg-info/SOURCES.txt
+src/abstract_solana.egg-info/dependency_links.txt
+src/abstract_solana.egg-info/requires.txt
+src/abstract_solana.egg-info/top_level.txt
+test/test_abstract_solana.py

abstract_solana-0.0.0.1/src/abstract_solana.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abstract_solana-0.0.0.1/src/abstract_solana.egg-info/requires.txt

@@ -0,0 +1,2 @@
+solders
+abstract_utilities

abstract_solana-0.0.0.1/src/abstract_solana.egg-info/top_level.txt

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

abstract_solana-0.0.0.1/test/test_abstract_solana.py

@@ -0,0 +1,111 @@
+from abstract_solana import *
+from spl.token.instructions import create_associated_token_account, get_associated_token_address
+from solders_rpc import *
+PUMP_FUN_PROGRAM = get_pubkey("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P")
+
+PUMP_FUN_ASSOC_TOKEN_ACC_PROG = get_pubkey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL")
+from abstract_solcatcher import *
+def get_solcatcher_api(endpoint,*args,**kwargs):
+    return get_async_response(get_solcatcher_endpoint,endpoint=endpoint,*args,**kwargs)
+def derive_associated_bonding_curve(mint):
+    return get_associated_token_address(derive_bonding_curve(mint)[0], get_pubkey(mint))
+def derive_bonding_curve(mint):
+    return Pubkey.find_program_address(["bonding-curve".encode(), bytes(get_pubkey(mint))],PUMP_FUN_PROGRAM)
+
+def get_balance_info(balanceInfo, programId, authority):
+    return next((bal for bal in balanceInfo if programId == bal.get("programId") and authority == bal.get("owner")), {})
+def get_balance_from_instruction(transfer_instruction, txnData):
+    preBalance = txnData["meta"].get("preTokenBalances", [])
+    postBalance = txnData["meta"].get("postTokenBalances", [])
+    
+    # Update transfer_instruction with source, destination, and authority
+    accounts = transfer_instruction.get("accounts", [])
+    transfer_instruction.update({
+        key: accounts[i] for i, key in enumerate(["source", "destination", "authority"])
+    })
+    
+    preBalanceInfo = get_balance_info(preBalance, transfer_instruction['programId'], transfer_instruction['authority'])
+    postBalanceInfo = get_balance_info(postBalance, transfer_instruction['programId'], transfer_instruction['authority'])
+    
+    amount = preBalanceInfo.get('uiTokenAmount', {}).get('amount', 0) - postBalanceInfo.get('uiTokenAmount', {}).get('amount', 0)
+    transfer_instruction['amount'] = amount
+    
+    return transfer_instruction
+def get_transfer_info(transfer_instructions, txnData):
+    for transfer_instruction in transfer_instructions:
+        updated_instruction = get_balance_from_instruction(transfer_instruction, txnData)
+        transfer_instruction.update(updated_instruction)
+    
+    return transfer_instructions
+async def async_getSignaturesForAddress(account: Pubkey,
+                                        before: Optional[Signature] = None,
+                                        until: Optional[Signature] = None,
+                                        limit: Optional[int] = None,
+                                        commitment: Optional[Commitment] = None,
+                                        errorProof=False):
+    """Returns confirmed signatures for transactions involving an address.
+
+    Signatures are returned backwards in time from the provided signature or
+    most recent confirmed block.
+
+    Args:
+        account: Account to be queried.
+        before: (optional) Start searching backwards from this transaction signature.
+            If not provided the search starts from the top of the highest max confirmed block.
+        until: (optional) Search until this transaction signature, if found before limit reached.
+        limit: (optional) Maximum transaction signatures to return (between 1 and 1,000, default: 1,000).
+        commitment: (optional) Bank state to query. It can be either "finalized", "confirmed" or "processed".
+
+    Example:
+        >>> solana_client = Client("http://localhost:8899")
+        >>> from solders.pubkey import Pubkey
+        >>> pubkey = Pubkey.from_string("Vote111111111111111111111111111111111111111")
+        >>> solana_client.get_signatures_for_address(pubkey, limit=1).value[0].signature # doctest: +SKIP
+        Signature(
+            1111111111111111111111111111111111111111111111111111111111111111,
+        )
+    """
+    account=get_pubkey(account)
+    before=get_sigkey(before)
+    until=until
+    limit=limit or 1000
+    commitment=commitment
+    response = json.loads(str(Client().get_signatures_for_address(account=account,before=before,until=until,limit=limit,commitment=commitment)))
+    signatureArray= await makeLimitedCall(response.get('method'),response.get('params'))
+    if errorProof:
+        signatureArray = [signatureData for signatureData in signatureArray if signatureData.get('err') == None]
+    return signatureArray
+def getsignaturesforaddress(account,before=None,until=None,limit=None,commitment=None,errorProof=None):
+    return get_async_response(async_getSignaturesForAddress,account=account,before=before,until=until,limit=limit,commitment=commitment,errorProof=errorProof)
+
+def get_transfer_instructions(txnData,programId=None):
+    programId = programId or PUMP_FUN_ASSOC_TOKEN_ACC_PROG
+    return get_transfer_info(find_in_catalog('transfer',txnData,programId=programId),txnData)
+async def async_getGenesisSignature(account,before=None,limit=1000,commitment=None):
+    method = "getGenesisSignature"
+    limit=1000
+
+    genesisSignature=None
+    if genesisSignature == None:
+        before = before or None
+        genesisSignature = None  # This will store the last seen valid signature
+        while True:
+            signatureArray = await getsignaturesforaddress(account=account,before=before,limit=limit,commitment=commitment)
+            signatureArrayInfo = return_oldest_last_and_original_length_from_signature_array(signatureArray)
+            genesisSignature = signatureArrayInfo.get("oldestValid") or genesisSignature
+
+            if before == signatureArrayInfo.get("oldest") or signatureArrayInfo.get("length") < limit:
+                #insert_Db(method.lower(), str(account), (str(account), str(genesisSignature)))
+                return genesisSignature 
+            before = signatureArrayInfo.get("oldest")
+    return genesisSignature  
+
+def getgenesissignature(account,before=None,limit=None,commitment=None):
+    return get_async_response(async_getGenesisSignature,account=account,before=before,limit=limit,commitment=commitment)
+
+mint = "911eA3wRZ85ZiSTpmCH1hksPGLGgzyVpfMXtJ4zSzVJ5"
+bondingCurve = str(derive_bonding_curve(mint))
+#input(getsignaturesforaddress(str(derive_bonding_curve(mint)[0])))
+input(getgenesissignature(str(derive_bonding_curve(mint)[0])))
+parsed_txn = get_solcatcher_api("getParsedTransaction",signature="2pQRuCawe8it1X4bvKZnmSZZfcLUXd3q1ki8z1kMBCKm52eU2obQxGSkpRR1tX88nquy5iNiycebit3BFsQaDPcx")
+input(get_transfer_instructions(parsed_txn,programId=PUMP_FUN_ASSOC_TOKEN_ACC_PROG))