abstract-solana 0.0.0.25__tar.gz → 0.0.0.27__tar.gz

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abstract_solana
-Version: 0.0.0.25
+Version: 0.0.0.27
 Home-page: https://github.com/AbstractEndeavors/abstract_solana
 Author: putkoff
 Author-email: partners@abstractendeavors.com

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_solana',
-    version='0.0.0.25',
+    version='0.0.0.27',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="",

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/src/abstract_solana/__init__.py

@@ -7,4 +7,4 @@ from .signature_data_parse import *
 from .utils import *
 from .log_message_functions import *
 from .constants import *
-from .pumpFunKeys import *
+from .pumpFun import *

abstract_solana-0.0.0.27/src/abstract_solana/pumpFun/__init__.py

@@ -0,0 +1,3 @@
+from .token_utils import *
+from .pump_fun_keys import *
+from .buy_sell_pump import *

abstract_solana-0.0.0.27/src/abstract_solana/pumpFun/buy_sell_pump.py

@@ -0,0 +1,158 @@
+import struct,base58,time
+from solders.hash import Hash
+from solders.keypair import Keypair
+from solders.instruction import Instruction
+from solana.rpc.types import TokenAccountOpts,TxOpts
+from solana.transaction import Transaction
+from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
+from .token_utils import get_token_balance
+def sendTransaction(txn: Transaction, payer_keypair, opts=TxOpts(skip_preflight=True)) -> dict:
+    # Sign the transaction
+    txn.sign(payer_keypair)
+    
+    # Serialize the transaction to a base64 string
+    txn_base64 = base58.b58encode(txn.serialize()).decode('utf-8')
+    
+    # Prepare the RPC request payload
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "sendTransaction",
+        "params": [txn_base64, {"skipPreflight": opts.skip_preflight, "preflightCommitment": "finalized"}]
+    }
+    
+    # Send the transaction
+    response = requests.post(
+        url="https://rpc.ankr.com/solana/c3b7fd92e298d5682b6ef095eaa4e92160989a713f5ee9ac2693b4da8ff5a370",
+        json=payload
+    )
+    
+    # Parse the JSON response
+    response_json = response.json()
+    
+    # Return the result or the entire response in case of error
+    return response_json.get('result', response_json)
+def confirm_txn(txn_sig, max_retries=20, retry_interval=3):
+    retries = 0
+    
+    while retries < max_retries:
+        try:
+            
+            txn_res = get_transaction(signature=str(txn_sig))
+            if txn_res:
+                print(txn_res)
+                print(f"\n\nhttps://solscan.io/tx/{str(txn_sig)}")
+                break
+            txn_json = safe_json_loads(txn_res.get('transaction',{}).get('meta',{}))
+            error = txn_json.get('err')
+            if error is None:
+                print("Transaction confirmed... try count:", retries+1)
+                return True
+            print("Error: Transaction not confirmed. Retrying...")
+            if error:
+                print("Transaction failed.")
+                return False
+        except Exception as e:
+            print("Awaiting confirmation... try count:", retries+1)
+            retries += 1
+            time.sleep(retry_interval)
+    print("Max retries reached. Transaction confirmation failed.")
+    return None
+def buildTxn(mint, amount, slippage, token_account_pubkey,sol_in=0,token_price=0,token_balance=0,token_account_instructions=None,close_token_account=False,buy=True):
+    # Get keys for the transaction, pass the token account's pubkey instead of the AccountMeta object
+    keys = getKeys(get_coin_data(mint), token_account_pubkey, owner,buy=buy)
+    slippage_adjustment = 1 - (slippage / 100)
+    sol_change = sol_in if buy else float(token_balance) * float(token_price)
+    sol_change_with_slippage = sol_change * slippage_adjustment
+    limit_sol_change = int(sol_change_with_slippage * LAMPORTS_PER_SOL)
+    print(f"Max Sol {'Cost' if buy else 'Output'}:", sol_change_with_slippage)
+    hex_data = bytes.fromhex("66063d1201daebea" if buy else "33e685a4017f83ad")
+    data = bytearray()
+    data.extend(hex_data)
+    data.extend(struct.pack('<Q', amount))
+    data.extend(struct.pack('<Q', limit_sol_change))
+    swap_instruction = Instruction(PUMP_FUN_PROGRAM_PUBKEY, bytes(data), keys)
+    blockHash = getLatestBlockhash(commitment="processed")
+    recent_blockhash = get_any_value(blockHash.json(),'blockhash')
+    recent_blockhash = Hash.from_string(recent_blockhash)
+    txn = Transaction(recent_blockhash=recent_blockhash, fee_payer=owner)
+    txn.add(set_compute_unit_price(UNIT_PRICE))
+    txn.add(set_compute_unit_limit(UNIT_BUDGET))
+    if buy and token_account_instructions:
+        txn.add(token_account_instructions)
+    txn.add(swap_instruction)
+    if buy == False and close_token_account:
+        close_account_instructions = close_account(CloseAccountParams(PUMP_FUN_PROGRAM_PUBKEY, token_account_pubkey, owner, owner))
+        txn.add(close_account_instructions)
+    txn.sign(payer_keypair)
+    txn_sig = sendTransaction(txn, payer_keypair, TxOpts(skip_preflight=True))
+    print("Transaction Signature", txn_sig)
+    confirm = confirm_txn(txn_sig)
+    print(confirm)
+def get_all_buy_sell_info(mint,payer_keypair=None,token_balance=None):
+    try:
+        payer_keypair = payer_keypair or load_from_private_key()
+        payer_pubkey = payer_keypair.pubkey()
+        print("Owner Public Key:", owner)
+        mint_str = str(mint)
+        if not get_pubkey(mint_str).is_on_curve():
+            print('Mint public key is not on curve')
+            return False
+        coin_data = get_pump_fun_data(mint_str)
+        print("Coin Data:", coin_data)
+        # Get coin data
+        coin_data = get_coin_data(mint_str)
+        print(coin_data)
+        if not coin_data:
+            print("Failed to retrieve coin data...")
+            return False
+        mint_pubkey = get_pubkey(mint_str)
+        token_account, token_account_instructions = check_existing_token_account(owner, mint_pubkey)
+        token_account_pubkey = get_pubkey(token_account)
+        # Ensure the token_account is a valid Pubkey
+        if not isinstance(token_account_pubkey, Pubkey):
+            print("Failed to create or retrieve a valid token account Pubkey...")
+            return False
+        print("Token Account:", token_account)
+        if not token_account:
+            print("Failed to retrieve or create token account.")
+            return False
+        # Calculate token price
+        token_price = get_token_price(mint_str)
+        print(f"Token Price: {token_price:.20f} SOL")
+        amount = int(sol_in_lamports * token_price)
+        print("Calculated Amount:", amount)
+        if token_balance == None:
+            token_balance = get_token_balance(token_account,mint_str)
+        print("Token Balance:", token_balance)
+        if token_balance == 0:
+            return False        
+        return mint,amount,token_balance,token_price,token_account_pubkey,token_account_instructions
+    except Exception as e:
+        print(e)
+        
+def pump_fun_sell(mint_str: str, token_balance: Optional[Union[int, float]] = None,  slippage: int = 25, close_token_account: bool = True) -> bool:
+        mint,amount,token_balance,token_price,token_account_pubkey,token_account_instructions = get_all_buy_sell_info(mint,payer_keypair,token_balance)
+        buildTxn(mint=mint,
+                 amount=amount,
+                 slippage=slippage,
+                 sol_in=0,
+                 token_balance=token_balance,
+                 token_price=token_price,
+                 token_account_pubkey=token_account_pubkey,
+                 token_account_instructions=token_account_instructions,
+                 buy=False)
+
+def pump_fun_buy(mint_str: str, sol_in: float = 0.001, slippage: int = 25) -> bool:
+    mint,amount,token_balance,token_price,token_account_pubkey,token_account_instructions = get_all_buy_sell_info(mint,payer_keypair)
+    # Build the transaction
+    buildTxn(mint=mint,
+             amount=amount,
+             slippage=slippage,
+             sol_in=sol_in,
+             token_balance=0,
+             token_price=0,
+             token_account_pubkey=token_account_pubkey,
+             token_account_instructions=token_account_instructions,
+             buy=True)
+    return True

abstract_solana-0.0.0.27/src/abstract_solana/pumpFun/pumpFunKeys.py

@@ -0,0 +1,129 @@
+from .pubkey_utils import Pubkey,get_pubkey,derive_bonding_curve,derive_associated_bonding_curve
+from .log_message_functions import get_for_program_ids_info
+from spl.token.instructions import create_associated_token_account, get_associated_token_address
+from abstract_solcatcher import getGenesisSignature,getTransaction,getAccountInfo
+from construct import Padding, Struct, Int64ul, Flag
+import base64
+from ..constants import (PUMP_FUN_GLOBAL_PUBKEY,
+                         PUMP_FUN_FEE_RECIPIENT_PUBKEY,
+                         SYSTEM_PROGRAM_PUBKEY,
+                         PUMP_FUN_EVENT_AUTHORITY_PUBKEY,
+                         PUMP_FUN_PROGRAM_PUBKEY,
+                         TOKEN_PROGRAM_ID_PUBKEY,
+                         RENT_PUBKEY,
+                         PUMP_FUN_ASSOC_TOKEN_ACC_PROG_PUBKEY)
+
+# Change dictionary keys to lowercase and replace spaces with underscores
+def change_keys_lower(dict_obj):
+    new_dict = {}
+    for key, value in dict_obj.items():
+        new_dict[key.lower().replace(' ', '_')] = value
+    return new_dict
+
+# Predefined map for different transaction types
+def get_create_map():
+    return [
+        {'instruction_number': '1', 'instruction_name': 'Mint', 'token_address': 'AkAUSJg1v9xYT3HUxdALH7NsrC6owmwoZuP9MLw8fxTL', 'token_name': '3CAT'},
+        {'instruction_number': '2', 'instruction_name': 'Mint Authority', 'token_address': 'TSLvdd1pWpHVjahSpsvCXUbgwsL3JAcvokwaKt1eokM', 'token_name': 'Pump.fun Token Mint Authority'},
+        {'instruction_number': '3', 'instruction_name': 'Bonding Curve', 'token_address': '9nhxvNxfSUaJddVco6oa6NodtsCscqCScp6UU1hZkfGm', 'token_name': 'Pump.fun (3CAT) Bonding Curve'},
+        {'instruction_number': '4', 'instruction_name': 'Associated Bonding Curve', 'token_address': '889XLp3qvVAHpTYQmhn6cBpYSppV8Gi8E2Rgp9RH2vRy', 'token_name': 'Pump.fun (3CAT) Vault'},
+        {'instruction_number': '5', 'instruction_name': 'Global', 'token_address': '4wTV1YmiEkRvAtNtsSGPtUrqRYQMe5SKy2uB4Jjaxnjf', 'token_name': '4wTV1YmiEkRvAtNtsSGPtUrqRYQMe5SKy2uB4Jjaxnjf'},
+        {'instruction_number': '6', 'instruction_name': 'Mpl Token Metadata', 'token_address': 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s', 'token_name': 'Metaplex Token Metadata'},
+        {'instruction_number': '7', 'instruction_name': 'Metadata', 'token_address': 'CH41RxpjSXHqr1vfLTVYJMsfNs2fBCCWoAE13tPihXh7', 'token_name': 'CH41RxpjSXHqr1vfLTVYJMsfNs2fBCCWoAE13tPihXh7'},
+        {'instruction_number': '8', 'instruction_name': 'User', 'token_address': 'Fuy5MvbgzjSok1U8hH6mUY6WnLynzUextDxfEWMiTkn4', 'token_name': 'Fuy5MvbgzjSok1U8hH6mUY6WnLynzUextDxfEWMiTkn4'},
+        {'instruction_number': '9', 'instruction_name': 'System Program', 'token_address': '11111111111111111111111111111111', 'token_name': 'System Program'},
+        {'instruction_number': '10', 'instruction_name': 'Token Program', 'token_address': 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', 'token_name': 'Token Program'},
+        {'instruction_number': '11', 'instruction_name': 'Associated Token Program', 'token_address': 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL', 'token_name': 'Associated Token Account Program'},
+        {'instruction_number': '12', 'instruction_name': 'Rent', 'token_address': 'SysvarRent111111111111111111111111111111111', 'token_name': 'Rent Program'},
+        {'instruction_number': '13', 'instruction_name': 'Event Authority', 'token_address': 'Ce6TQqeHC9p8KetsN6JsjHK7UTZk7nasjjnr7XxXp9F1', 'token_name': 'Ce6TQqeHC9p8KetsN6JsjHK7UTZk7nasjjnr7XxXp9F1'},
+        {'instruction_number': '14', 'instruction_name': 'Program', 'token_address': '6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P', 'token_name': 'Pump.fun'}
+    ]
+
+# Fetches and organizes transaction types based on provided mint
+def getTxnTypes(mint):
+    bonding_curve = str(derive_bonding_curve(mint)[0])
+    bonding_curve_signature = getGenesisSignature(address=bonding_curve)
+    txn_data = getTransaction(signature=bonding_curve_signature)
+    txn_data = get_for_program_ids_info(txn_data)
+
+    for new_map in get_create_map():
+        instructions = txn_data['transaction']['message']['instructions']
+        inner_instructions = txn_data['meta']['innerInstructions'][0]['instructions']
+        all_instructions = instructions + inner_instructions
+
+        instruction = [inst for inst in all_instructions if len(inst.get('associatedAccounts', [])) > 13]
+        
+        txn_types = {create_index['instruction_name']: instruction[0]['associatedAccounts'][int(create_index['instruction_number']) - 1] for create_index in get_create_map()}
+
+        if txn_types:
+            txn_types['signature'] = bonding_curve_signature
+            break
+    return txn_types
+
+# Retrieve virtual reserves for a bonding curve using a structured layout
+def get_virtual_reserves(bonding_curve: Pubkey):
+    bonding_curve_struct = Struct(
+        Padding(8),
+        "virtualTokenReserves" / Int64ul,
+        "virtualSolReserves" / Int64ul,
+        "realTokenReserves" / Int64ul,
+        "realSolReserves" / Int64ul,
+        "tokenTotalSupply" / Int64ul,
+        "complete" / Flag
+    )
+    account_info = getAccountInfo(account=str(bonding_curve[0]))
+    
+    if not account_info or 'value' not in account_info or 'data' not in account_info['value']:
+        print("Failed to retrieve account info.")
+        return None
+
+    data_base64 = account_info['value']['data'][0]
+    data = base64.b64decode(data_base64)
+    parsed_data = bonding_curve_struct.parse(data)
+    return parsed_data
+
+# Retrieves comprehensive transaction and reserve data for the mint
+def get_pump_fun_data(mint_str: str):
+    txn_types = change_keys_lower(getTxnTypes(mint_str))
+    bonding_curve = derive_bonding_curve(mint_str)
+    virtual_reserves = get_virtual_reserves(bonding_curve)
+    if virtual_reserves is None:
+        return None
+
+    txn_types.update({
+        "mint": mint_str,
+        "bonding_curve": str(bonding_curve[0]),
+        "associated_bonding_curve": str(derive_associated_bonding_curve(mint_str)),
+        "virtual_token_reserves": int(virtual_reserves.virtualTokenReserves),
+        "virtual_sol_reserves": int(virtual_reserves.virtualSolReserves),
+        "token_total_supply": int(virtual_reserves.tokenTotalSupply),
+        "complete": bool(virtual_reserves.complete)
+    })
+    
+    return txn_types
+
+def getKeys(mint_str,token_account,payer_pubkey,buy=True):
+    coin_data = get_pump_fun_data(str(mint_str))
+    MINT = get_pubkey(mint_str)
+    BONDING_CURVE = get_pubkey(coin_data['bonding_curve'])
+    ASSOCIATED_BONDING_CURVE = get_pubkey(coin_data['associated_bonding_curve'])
+    ASSOCIATED_USER = get_pubkey(token_account)
+    USER = get_pubkey(payer_pubkey)
+    PUMP_FUN_TOKEN_PROGRAM_SWITCH = TOKEN_PROGRAM_ID_PUBKEY if buy else PUMP_FUN_ASSOC_TOKEN_ACC_PROG_PUBKEY
+    PUMP_FUN_RENT_PROGRAM_SWITCH = RENT_PUBKEY if buy else TOKEN_PROGRAM_ID_PUBKEY
+    # Build account key list 
+    keys = [
+        AccountMeta(pubkey=PUMP_FUN_GLOBAL_PUBKEY, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=PUMP_FUN_FEE_RECIPIENT_PUBKEY, is_signer=False, is_writable=True),
+        AccountMeta(pubkey=MINT, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=BONDING_CURVE, is_signer=False, is_writable=True),
+        AccountMeta(pubkey=ASSOCIATED_BONDING_CURVE, is_signer=False, is_writable=True),
+        AccountMeta(pubkey=ASSOCIATED_USER, is_signer=False, is_writable=True),
+        AccountMeta(pubkey=USER, is_signer=True, is_writable=True),
+        AccountMeta(pubkey=SYSTEM_PROGRAM_PUBKEY, is_signer=False, is_writable=False), 
+        AccountMeta(pubkey=PUMP_FUN_TOKEN_PROGRAM_SWITCH, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=PUMP_FUN_RENT_PROGRAM_SWITCH, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=PUMP_FUN_EVENT_AUTHORITY_PUBKEY, is_signer=False, is_writable=False),
+        AccountMeta(pubkey=PUMP_FUN_PROGRAM_PUBKEY, is_signer=False, is_writable=False)
+    ]
+    return keys

abstract_solana-0.0.0.27/src/abstract_solana/pumpFun/token_utils.py

@@ -0,0 +1,49 @@
+from ..constants import TOKEN_DECIMAL_EXP,SOL_DECIMAL_EXP
+from ..pubkey_utils import Pubkey
+from abstract_solcatcher import getTokenAccountBalance,getTokenAccountsByOwner
+from spl.token.instructions import create_associated_token_account, get_associated_token_address
+from abstract_utilities import get_any_value
+def get_token_balance(payer,mint_str: str):
+    response = getTokenAccountBalance(str(payer),str(mint_str))
+    response=response.get('value',response)
+    ui_amount = get_any_value(response, "uiAmount") or 0
+    return float(ui_amount)
+def get_token_price(mint_str: str) -> float:
+    try:
+        # Get coin data
+        coin_data = get_coin_data(mint_str)
+        if not coin_data:
+            print("Failed to retrieve coin data...")
+            return None
+        virtual_sol_reserves = coin_data['virtual_sol_reserves'] / SOL_DECIMAL_EXP
+        virtual_token_reserves = coin_data['virtual_token_reserves'] / TOKEN_DECIMAL_EXP
+        token_price = virtual_sol_reserves / virtual_token_reserves
+        print(f"Token Price: {token_price:.20f} SOL")
+        return token_price
+    except Exception as e:
+        print(f"Error calculating token price: {e}")
+        return None
+def get_account_by_owner(payer, mint_str: str) -> dict:
+    result = getTokenAccountsByOwner(**{"account":payer,"mint":mint,"encoding":"jsonParsed"})
+    if not result or 'value' not in result:
+        return None
+
+    accounts = result.get('value', [])
+    if accounts:
+        return accounts[0]  # Return the first account found
+    return None
+def check_existing_token_account(owner: Pubkey, mint: Pubkey):
+    try:
+        account_data = get_account_by_owner(str(owner), str(mint))
+        if account_data:
+            token_account = account_data['pubkey']
+            print(f"Existing token account found: {token_account}")
+            return token_account, None
+        else:
+            print("No existing token account found. Creating a new one...")
+            token_account = get_associated_token_address(owner, mint)
+            token_account_instructions = create_associated_token_account(owner, owner, mint)
+            return token_account, token_account_instructions
+    except Exception as e:
+        print(f"Error checking or creating token account: {e}")
+        return None, None

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/src/abstract_solana.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abstract_solana
-Version: 0.0.0.25
+Version: 0.0.0.27
 Home-page: https://github.com/AbstractEndeavors/abstract_solana
 Author: putkoff
 Author-email: partners@abstractendeavors.com

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/src/abstract_solana.egg-info/SOURCES.txt

@@ -16,4 +16,8 @@ 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
+src/abstract_solana/pumpFun/__init__.py
+src/abstract_solana/pumpFun/buy_sell_pump.py
+src/abstract_solana/pumpFun/pumpFunKeys.py
+src/abstract_solana/pumpFun/token_utils.py
 test/test_abstract_solana.py

{abstract_solana-0.0.0.25 → abstract_solana-0.0.0.27}/test/test_abstract_solana.py

@@ -1,5 +1,4 @@
-from abstract_solana import Pubkey,get_pubkey,Optional,Union,LAMPORTS_PER_SOL,get_any_value
-
+from abstract_solana.pumpFun import pump_fun_sell
 from abstract_solcatcher import *
  #type: ignore
 mint_str = "3bb6QmvustnZ627Kg2QvwTSi8gmxp7Y6orwXUokEwUyV"