abstract-solana 0.0.0.93__py3-none-any.whl → 0.0.0.94__py3-none-any.whl

abstract_solana/pump_functions/__init__.py

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

abstract_solana/pump_functions/buy_sell_pump.py

@@ -0,0 +1,149 @@
+import struct,base58,time,requests,asyncio,time
+from typing import Optional,Union
+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 abstract_solcatcher import getLatestBlockHash,sendTransaction,getTransaction
+from abstract_utilities import get_any_value
+from ..pubkey_utils import Pubkey,get_pubkey
+from spl.token.instructions import CloseAccountParams,close_account
+from ..constants import TOKEN_PROGRAM_ID_PUBKEY,LAMPORTS_PER_SOL,UNIT_PRICE,UNIT_BUDGET
+from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
+from .token_utils import get_token_balance,check_existing_token_account,get_token_price
+from .pump_fun_keys import getKeys
+def buildTxn(mint,payer_pubkey, amount, slippage, token_account,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(mint, token_account=token_account, payer_pubkey=payer_pubkey,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,'blockhash')
+    recent_blockhash = Hash.from_string(recent_blockhash)
+    txn = Transaction(recent_blockhash=recent_blockhash, fee_payer=payer_pubkey)
+    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, payer_pubkey, payer_pubkey))
+        txn.add(close_account_instructions)
+    return txn
+
+def get_all_buy_sell_info(mint,payer_pubkey,token_balance=None,sol_in=0,buy=True):
+    
+        print("Owner Public Key:", payer_pubkey)
+        mint_str = str(mint)
+        if not get_pubkey(mint_str).is_on_curve():
+            print('Mint public key is not on curve')
+            return False,amount,token_balance,token_price,token_account,token_account_instructions
+        mint_pubkey = get_pubkey(mint_str)
+        token_account, token_account_instructions = check_existing_token_account(payer_pubkey, 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,amount,token_balance,token_price,token_account,token_account_instructions
+        print("Token Account:", token_account)
+        if not token_account:
+            print("Failed to retrieve or create token account.")
+            return False,amount,token_balance,token_price,token_account,token_account_instructions
+        # Calculate token price
+        token_price = get_token_price(mint_str)
+        print(f"Token Price: {token_price:.20f} SOL")
+        amount = int(LAMPORTS_PER_SOL * token_price)
+        print("Calculated Amount:", amount)
+        if buy == False:
+            if token_balance == None:
+                token_balance = get_token_balance(token_account,mint_str)
+            print("Token Balance:", token_balance)
+            if token_balance == 0:
+                return False,amount,token_balance,token_price,token_account,token_account_instructions        
+        return mint,amount,token_balance,token_price,token_account_pubkey,token_account_instructions
+
+def pump_fun_sell(mint: str,payer_pubkey:Pubkey, token_balance: Optional[Union[int, float]] = None,  slippage: int = 25, close_token_account: bool = True) -> bool:
+    mint,amount,token_balance,token_price,token_account,token_account_instructions = get_all_buy_sell_info(mint,payer_pubkey,token_balance=token_balance,buy=False)
+    if not mint:
+        return mint
+    return buildTxn(mint=mint,
+             payer_pubkey=payer_pubkey,
+             amount=amount,
+             slippage=slippage,
+             sol_in=0,
+             token_balance=token_balance,
+             token_price=token_price,
+             token_account=token_account,
+             token_account_instructions=token_account_instructions,
+             buy=False)
+
+def pump_fun_buy(mint: str,payer_pubkey:Pubkey, sol_in: float = 0.001, slippage: int = 25) -> bool:
+    mint,amount,token_balance,token_price,token_account,token_account_instructions = get_all_buy_sell_info(mint,payer_pubkey,sol_in=sol_in,buy=True)
+    if not mint:
+        return mint
+    return buildTxn(mint=mint,
+             payer_pubkey=payer_pubkey,
+             amount=amount,
+             slippage=slippage,
+             sol_in=sol_in,
+             token_balance=0,
+             token_price=0,
+             token_account=token_account,
+             token_account_instructions=token_account_instructions,
+             buy=True)
+    return True
+async def confirm_txn(txn_sig, max_retries=20, retry_interval=3):
+    retries = 0
+    while retries < max_retries:
+        txn_res = await getTransaction(signature=str(txn_sig))
+        if txn_res:
+            print(f"\n\nhttps://solscan.io/tx/{str(txn_sig)}")
+            return txn_res
+        retries += 1
+        print(f"Retrying... ({retries}/{max_retries})")
+        await asyncio.sleep(retry_interval)
+    print(f"Failed to confirm transaction after {max_retries} attempts.")
+    return txn_sig
+
+async def complete_txn(txn, payer_keypair,confirm=False):
+    txn_sig = await sendTransaction(txn=txn, payer_keypair=payer_keypair, skip_preflight=True)  # Await this async call
+    print("Transaction Signature", txn_sig)
+    if confirm == False:
+        return txn_sig
+    confirm = await confirm_txn(txn_sig)  # Await confirmation
+
+    while not confirm:
+        print("Waiting for transaction confirmation...")
+        await asyncio.sleep(1)  # Use asyncio.sleep instead of time.sleep to avoid blocking
+        confirm = await confirm_txn(txn_sig)  # Await confirmation check again
+
+    print("Transaction confirmed:", confirm)
+    return confirm
+def buy_pump(mint: str, payer_keypair: Pubkey, sol_in=None, slippage=None,confirm=False):
+    sol_in = sol_in or 0.001
+    slippage = slippage or 25
+    payer_pubkey = get_pubkey(payer_keypair.pubkey())
+    txn = pump_fun_buy(mint=mint, payer_pubkey=payer_pubkey, sol_in=sol_in, slippage=slippage)
+    completed = asyncio.run(complete_txn(txn, payer_keypair,confirm=confirm))  # Await here since `complete_txn` is async
+    if not completed:
+        print("Buy transaction failed")
+    return completed
+        
+def sell_pump(mint:str, payer_keypair:Pubkey, token_balance=None, slippage=None,confirm=False):
+    slippage = slippage or 25
+    payer_pubkey = get_pubkey(payer_keypair.pubkey())
+    txn = pump_fun_sell(mint=mint, payer_pubkey=payer_pubkey, token_balance=token_balance, slippage=slippage)
+    completed = asyncio.run(complete_txn(txn, payer_keypair,confirm=confirm))
+    if not completed:
+        print("sell transaction failed")
+    return completed

abstract_solana/pump_functions/pump_fun_keys.py

@@ -0,0 +1,133 @@
+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
+from solana.transaction import AccountMeta, Transaction
+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'}
+    ]
+
+def get_txnTypesFromGenesisSignature(genesisSignature,commitment="finalized"):
+    txn_data = getTransaction(genesisSignature,commitment=commitment)
+    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'] = genesisSignature
+            break
+    return txn_types
+
+# 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)
+    return get_txnTypesFromGenesisSignature(bonding_curve_signature)
+# 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=None,signature=None,commitment="finalized"):
+    if mint_str:
+        txn_types = change_keys_lower(getTxnTypes(mint_str))
+    if signature:
+        txn_types = change_keys_lower(get_txnTypesFromGenesisSignature(signature,commitment=commitment))
+    mint_str = mint_str or txn_types.get('mint')
+    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):
+    MINT = get_pubkey(str(mint_str))
+    bonding_curve = derive_bonding_curve(str(mint_str))
+    associated_bonding_curve = derive_associated_bonding_curve(str(mint_str))
+    BONDING_CURVE = get_pubkey(str(bonding_curve[0]))
+    ASSOCIATED_BONDING_CURVE = get_pubkey(str(associated_bonding_curve))
+    ASSOCIATED_USER = Pubkey.from_string(str(token_account))
+    USER = Pubkey.from_string(str(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/pump_functions/token_utils.py

@@ -0,0 +1,63 @@
+from ..constants import TOKEN_DECIMAL_EXP,SOL_DECIMAL_EXP
+from ..pubkey_utils import Pubkey
+from .pump_fun_keys import get_pump_fun_data
+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
+import requests
+def get_token_balance(payer,mint: str):
+    response = getTokenAccountBalance(str(payer),str(mint))
+    response=response.get('value',response)
+    ui_amount = get_any_value(response, "uiAmount") or 0
+    return float(ui_amount)
+def get_token_price(mint: str) -> float:
+    try:
+        # Get coin data
+        coin_data = get_pump_fun_data(str(mint))
+        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:
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "getTokenAccountsByOwner",
+        "params": [payer, {"mint": mint_str}, {"encoding": "jsonParsed"}]
+    }
+    response = requests.post(
+        url="https://rpc.ankr.com/solana/c3b7fd92e298d5682b6ef095eaa4e92160989a713f5ee9ac2693b4da8ff5a370",
+        json=payload
+    )
+    response_json = response.json()
+
+    result = response_json.get('result')
+    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.93.dist-info → abstract_solana-0.0.0.94.dist-info}/METADATA

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

{abstract_solana-0.0.0.93.dist-info → abstract_solana-0.0.0.94.dist-info}/RECORD

@@ -28,7 +28,11 @@ abstract_solana/pumpFun/buy_sell_pump.py,sha256=Nzs4G-Qednz5N6OKZq48ScqDdICXPapJ
 abstract_solana/pumpFun/pumpFunKeys.py,sha256=yMS_fT-0ESndluVpZ17XdMhpXVtSfhtIG5njy7DJkfI,7961
 abstract_solana/pumpFun/pump_fun_keys.py,sha256=jj_yLqXnVipuT9MalM7wp7x1LLmuE6c5mDQtRruxUTE,8492
 abstract_solana/pumpFun/token_utils.py,sha256=NhMvpTnw3QZk8DmeKYFzuqEMEZEHUlrBKfFp7662ohw,2684
-abstract_solana-0.0.0.93.dist-info/METADATA,sha256=9IYRn2dPOVwaXd5TtAxeAhFK3HlHwhoRDfgxMljodLE,981
-abstract_solana-0.0.0.93.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-abstract_solana-0.0.0.93.dist-info/top_level.txt,sha256=SsJYent8eZQ0FU2jmP8wTj7aFZFhNwxxP-5cCTQ2B-o,16
-abstract_solana-0.0.0.93.dist-info/RECORD,,
+abstract_solana/pump_functions/__init__.py,sha256=BiRxwJd1JWwEft63zqYwZ_Xs6UDp4hjczjzvuwy3sHg,85
+abstract_solana/pump_functions/buy_sell_pump.py,sha256=Nzs4G-Qednz5N6OKZq48ScqDdICXPapJTE7Df9OHwac,7830
+abstract_solana/pump_functions/pump_fun_keys.py,sha256=jj_yLqXnVipuT9MalM7wp7x1LLmuE6c5mDQtRruxUTE,8492
+abstract_solana/pump_functions/token_utils.py,sha256=NhMvpTnw3QZk8DmeKYFzuqEMEZEHUlrBKfFp7662ohw,2684
+abstract_solana-0.0.0.94.dist-info/METADATA,sha256=RTc4l8DtImEH_iYQ4W29aWUCZiI-H3uDCd-_yubeXd4,981
+abstract_solana-0.0.0.94.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+abstract_solana-0.0.0.94.dist-info/top_level.txt,sha256=SsJYent8eZQ0FU2jmP8wTj7aFZFhNwxxP-5cCTQ2B-o,16
+abstract_solana-0.0.0.94.dist-info/RECORD,,