abstract-solana 0.0.0.60__tar.gz → 0.0.0.62__tar.gz

{abstract_solana-0.0.0.60 → abstract_solana-0.0.0.62}/PKG-INFO

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

{abstract_solana-0.0.0.60 → abstract_solana-0.0.0.62}/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.60',
+    version='0.0.0.62',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="",

{abstract_solana-0.0.0.60 → abstract_solana-0.0.0.62}/src/abstract_solana/pumpFun/buy_sell_pump.py

@@ -1,11 +1,11 @@
-import struct,base58,time,requests
+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
+from abstract_solcatcher import getLatestBlockHash,getTransaction
 from abstract_utilities import get_any_value
 from ..pubkey_utils import Pubkey,get_pubkey
 from spl.token.instructions import CloseAccountParams,close_account
@@ -13,61 +13,34 @@ from ..constants import PUMP_FUN_PROGRAM_PUBKEY,LAMPORTS_PER_SOL,UNIT_PRICE,UNIT
 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 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):
+from abstract_solcatcher import sendTransaction,getTransaction
+async 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,payer_pubkey, amount, slippage, token_account_pubkey,sol_in=0,token_price=0,token_balance=0,token_account_instructions=None,close_token_account=False,buy=True):
+        txn_res = await getTransaction(signature=str(txn_sig))
+        print(txn_res)
+        if txn_res:
+            print(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
+def complete_txn(txn, payer_keypair):
+    txn_sig = sendTransaction(txn=txn, payer_keypair=payer_keypair, skip_preflight=True))
+    print("Transaction Signature", txn_sig)
+    confirm = asyncio.run(confirm_txn(txn_sig))
+    while not confirm:
+        print("Waiting for transaction confirmation...")
+        time.sleep(1)  # Wait for 1 second before checking again
+        confirm = confirm_txn(txn_sig)
+    print("Transaction confirmed:", confirm)
+    return confirm
+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_pubkey=token_account_pubkey, payer_pubkey=payer_pubkey,buy=buy)
+    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
@@ -93,40 +66,41 @@ def buildTxn(mint,payer_pubkey, amount, slippage, token_account_pubkey,sol_in=0,
         txn.add(close_account_instructions)
     return txn
 
-def get_all_buy_sell_info(mint,payer_pubkey,token_balance=None,sol_in=0):
-    try:
+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
+            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
+            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
+            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 token_balance == None:
-            token_balance = get_token_balance(token_account,mint_str)
-        print("Token Balance:", token_balance)
-        if token_balance == 0:
-            return False        
+        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
-    except Exception as e:
-        print(e)
-        
+
 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_pubkey,token_account_instructions = get_all_buy_sell_info(mint,payer_pubkey,token_balance=token_balance)
+    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,
@@ -134,13 +108,14 @@ def pump_fun_sell(mint: str,payer_pubkey:Pubkey, token_balance: Optional[Union[i
              sol_in=0,
              token_balance=token_balance,
              token_price=token_price,
-             token_account_pubkey=token_account_pubkey,
+             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_pubkey,token_account_instructions = get_all_buy_sell_info(mint,payer_pubkey,sol_in=sol_in)
-    # Build the transaction
+    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,
@@ -148,7 +123,23 @@ def pump_fun_buy(mint: str,payer_pubkey:Pubkey, sol_in: float = 0.001, slippage:
              sol_in=sol_in,
              token_balance=0,
              token_price=0,
-             token_account_pubkey=token_account_pubkey,
+             token_account=token_account,
              token_account_instructions=token_account_instructions,
              buy=True)
     return True
+
+def buy_pump(mint=mint_str, payer_keypair=payer_keypair,sol_in=0.001,slippage=25)
+    payer_pubkey = get_pubkey(payer_keypair.pubkey())
+    txn = pump_fun_buy(mint=mint_str, payer_pubkey=payer_pubkey,sol_in=sol_in,slippage=slippage)
+    completed = complete_txn(txn, payer_keypair)
+    if not completed:
+        print("Buy transaction failed")
+    return completed
+        
+def sell_pump(mint=mint_str, payer_keypair=payer_keypair, token_balance=None, slippage=25)
+    payer_pubkey = get_pubkey(payer_keypair.pubkey())
+    txn = pump_fun_sell(mint=mint_str, payer_pubkey=payer_pubkey, token_balance=token_balance, slippage=slippage)
+    completed = complete_txn(txn, payer_keypair)
+    if not completed:
+        print("sell transaction failed")
+    return completed

{abstract_solana-0.0.0.60 → abstract_solana-0.0.0.62}/src/abstract_solana.egg-info/PKG-INFO

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

{abstract_solana-0.0.0.60 → abstract_solana-0.0.0.62}/test/test_abstract_solana.py

@@ -1,11 +1,11 @@
 from spl.token.instructions import CloseAccountParams
-from abstract_solana import get_pubkey,confirm_txn,pump_fun_buy,load_from_private_key,sendTransaction,load_from_private_key
+from src.abstract_solana import get_pubkey,confirm_txn,pump_fun_sell,pump_fun_buy,load_from_private_key,sendTransaction,load_from_private_key
 from solana.rpc.types import TxOpts
 payer_keypair = load_from_private_key()
 payer_pubkey = get_pubkey(payer_keypair.pubkey())
 mint_str = "3bb6QmvustnZ627Kg2QvwTSi8gmxp7Y6orwXUokEwUyV"
-#txn = pump_fun_sell(mint=mint_str,payer_pubkey=payer_pubkey, token_balance=None, slippage=25)
-txn = pump_fun_buy(mint=mint_str,payer_pubkey=payer_pubkey)
+txn = pump_fun_sell(mint=mint_str,payer_pubkey=payer_pubkey, token_balance=None, slippage=25)
+#txn = pump_fun_buy(mint=mint_str,payer_pubkey=payer_pubkey)
 txn.sign(payer_keypair)
 txn_sig = sendTransaction(txn, payer_keypair, TxOpts(skip_preflight=True))
 print("Transaction Signature", txn_sig)