v12.4.0

Author: truemagic-coder

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sakit"
-version = "12.3.0"
+version = "12.4.0"
 description = "Solana Agent Kit"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"
@@ -17,10 +17,10 @@ packages = [{ include = "sakit" }]
 python = ">=3.12,<4.0"
 httpx = "^0.28.1"
 solana-agent = ">=30.0.0"
-boto3 = "^1.38.32"
-botocore = "^1.38.32"
+boto3 = "^1.38.36"
+botocore = "^1.38.36"
 nemo-agent = "5.0.3"
-fastmcp = "^2.7.1"
+fastmcp = "^2.8.1"
 solana = "^0.36.7"
 solders = "^0.26.0"
 pynacl = "^1.5.0"

pyproject.toml

@@ -95,6 +95,7 @@ def __init__(self, registry: Optional[ToolRegistry] = None):
         self.rpc_url = None
         self.jupiter_url = None
         self.fee_payer = None
+        self.fee_percentage = 0.85  # Default fee percentage (0.85% = 0.0085)
 
     def get_schema(self) -> Dict[str, Any]:
         return {
@@ -126,6 +127,7 @@ def configure(self, config: Dict[str, Any]) -> None:
         self.rpc_url = tool_cfg.get("rpc_url")
         self.jupiter_url = tool_cfg.get("jupiter_url")
         self.fee_payer = tool_cfg.get("fee_payer")
+        self.fee_percentage = tool_cfg.get("fee_percentage", 0.85)  # Default 0.85% fee
 
     async def execute(
         self,
@@ -158,6 +160,9 @@ async def execute(
             wallet = SolanaWalletClient(
                 self.rpc_url, None, wallet_info["public_key"], self.fee_payer
             )
+            provider = None
+            if "helius" in self.rpc_url:
+                provider = "helius"
             transaction = await TradeManager.trade(
                 wallet,
                 output_mint,
@@ -166,6 +171,8 @@ async def execute(
                 slippage_bps,
                 self.jupiter_url,
                 True,
+                provider,
+                self.fee_percentage,
             )
             encoded_transaction = base64.b64encode(bytes(transaction)).decode("utf-8")
             result = await privy_sign_and_send(

sakit/privy_swap.py

@@ -98,6 +98,7 @@ def __init__(self, registry: Optional[ToolRegistry] = None):
         self.signing_key = None
         self.rpc_url = None
         self.fee_payer = None
+        self.fee_percentage = None
 
     def get_schema(self) -> Dict[str, Any]:
         return {
@@ -128,6 +129,7 @@ def configure(self, config: Dict[str, Any]) -> None:
         self.signing_key = tool_cfg.get("signing_key")
         self.rpc_url = tool_cfg.get("rpc_url")
         self.fee_payer = tool_cfg.get("fee_payer")
+        self.fee_percentage = tool_cfg.get("fee_percentage", 0.85)  # Default 0.85% fee
 
     async def execute(
         self,
@@ -163,7 +165,7 @@ async def execute(
             if "helius" in self.rpc_url:
                 provider = "helius"
             transaction = await TokenTransferManager.transfer(
-                wallet, to_address, amount, mint, provider, True
+                wallet, to_address, amount, mint, provider, True, self.fee_percentage
             )
             encoded_transaction = base64.b64encode(bytes(transaction)).decode("utf-8")
             result = await privy_sign_and_send(

sakit/privy_transfer.py

@@ -1,21 +1,62 @@
 import logging
 import base64
-from typing import Optional
+from typing import Optional, List
 import httpx
 
 from solders.pubkey import Pubkey
+from solana.rpc.commitment import Finalized
 from solders.transaction import VersionedTransaction
-from solders.message import to_bytes_versioned
-from solders.null_signer import NullSigner
+from solders.message import (
+    to_bytes_versioned,
+    MessageV0,
+)
+from spl.token.instructions import (
+    transfer_checked as spl_transfer,
+    TransferCheckedParams as SPLTransferParams,
+)
 from spl.token.async_client import AsyncToken
+from solders.address_lookup_table_account import AddressLookupTableAccount
+from solders.null_signer import NullSigner
+from solders.hash import Hash
+from solders.instruction import Instruction, AccountMeta
+from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
+from solders.signature import Signature
 from sakit.utils.wallet import SolanaWalletClient
+from sakit.utils.transfer import transfer, TransferParams
 
 JUP_API = "https://quote-api.jup.ag/v6"
 SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
 TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
-
+LAMPORTS_PER_SOL = 10**9
 
 class TradeManager:
+    @staticmethod
+    def parse_address_table_lookups(addresses):
+        if not addresses:
+            return []
+        if isinstance(addresses, str):
+            addresses = [addresses]
+        # Use empty addresses for simulation/compilation
+        return [AddressLookupTableAccount(Pubkey.from_string(addr), []) for addr in addresses]
+
+    @staticmethod
+    def parse_instruction(ix_obj) -> Instruction:
+        program_id = Pubkey.from_string(ix_obj["programId"])
+        accounts = [
+            AccountMeta(
+                pubkey=Pubkey.from_string(acc["pubkey"]),
+                is_signer=acc["isSigner"],
+                is_writable=acc["isWritable"],
+            )
+            for acc in ix_obj["accounts"]
+        ]
+        data = base64.b64decode(ix_obj["data"])
+        return Instruction(program_id=program_id, accounts=accounts, data=data)
+
+    @staticmethod
+    def parse_instruction_list(ix_list) -> List[Instruction]:
+        return [TradeManager.parse_instruction(ix) for ix in ix_list]
+
     @staticmethod
     async def trade(
         wallet: SolanaWalletClient,
@@ -25,34 +66,15 @@ async def trade(
         slippage_bps: int = 300,
         jupiter_url: Optional[str] = None,
         no_signer: bool = False,
+        provider: Optional[str] = None,
+        fee_percentage: float = 0.85,
     ) -> VersionedTransaction:
         """
-        Swap tokens using Jupiter Exchange.
-
-        Args:
-            wallet: SolanaWalletClient instance.
-            output_mint (str): Target token mint address.
-            input_amount (float): Amount to swap.
-            input_mint (str): Source token mint address (default: SOL).
-            slippage_bps (int): Slippage tolerance in basis points (default: 300 = 3%).
-            jupiter_url (str): Jupiter API base URL.
-            no_signer (bool): If True, does not sign the transaction with the wallet's keypair.
-
-        Returns:
-            VersionedTransaction: Signed transaction ready for submission.
-
-        Raises:
-            Exception: If the swap fails.
+        Swap tokens using Jupiter Exchange, with compute budget and optional priority fee (if provider == 'helius').
         """
         try:
-            if (
-                input_mint is None
-                or input_mint == "So11111111111111111111111111111111111111112"
-            ):
-                # Default to SOL
-                input_mint = "So11111111111111111111111111111111111111112"
-                adjusted_amount = int(input_amount * (10**9))  # SOL has 9 decimals
-
+            if input_mint == "So11111111111111111111111111111111111111112":
+                adjusted_amount = int(input_amount * LAMPORTS_PER_SOL)
             else:
                 mint_pubkey = Pubkey.from_string(input_mint)
                 resp = await wallet.client.get_account_info(mint_pubkey)
@@ -65,11 +87,8 @@ async def trade(
                     raise ValueError(
                         f"Unsupported token program: {owner}. Supported programs are SPL Token and Token 2022."
                     )
-
-                token = AsyncToken(
-                    wallet.client, mint_pubkey, program_id, wallet.fee_payer
-                )
-
+                from spl.token.async_client import AsyncToken
+                token = AsyncToken(wallet.client, mint_pubkey, program_id, wallet.fee_payer)
                 mint_info = await token.get_mint_info()
                 adjusted_amount = int(input_amount * (10**mint_info.decimals))
 
@@ -94,8 +113,8 @@ async def trade(
                     )
                 quote_data = quote_response.json()
 
-                swap_response = await client.post(
-                    f"{jupiter_url}/swap",
+                swap_instructions_response = await client.post(
+                    f"{jupiter_url}/swap-instructions",
                     json={
                         "quoteResponse": quote_data,
                         "userPublicKey": str(wallet.pubkey),
@@ -104,31 +123,148 @@ async def trade(
                         "prioritizationFeeLamports": "auto",
                     },
                 )
-                if swap_response.status_code != 200:
+                if swap_instructions_response.status_code != 200:
                     raise Exception(
-                        f"Failed to fetch swap transaction: {swap_response.status_code}"
+                        f"Failed to fetch swap instructions: {swap_instructions_response.status_code}"
                     )
-                swap_data = swap_response.json()
+                swap_instructions_data = swap_instructions_response.json()
 
-            swap_transaction_buf = base64.b64decode(swap_data["swapTransaction"])
-            transaction = VersionedTransaction.from_bytes(swap_transaction_buf)
+            # Build all instructions in order
+            instructions = []
 
-            if no_signer:
-                signature = NullSigner(wallet.pubkey).sign_message(
-                    to_bytes_versioned(transaction.message)
-                )
-                signed_transaction = VersionedTransaction.populate(
-                    transaction.message, [signature]
+            # 1. Compute budget instructions (if present)
+            has_cu = (
+                "computeBudgetInstructions" in swap_instructions_data
+                and swap_instructions_data["computeBudgetInstructions"]
+            )
+            if has_cu:
+                instructions += TradeManager.parse_instruction_list(swap_instructions_data["computeBudgetInstructions"])
+
+            # 2. Setup instructions (if present)
+            if "setupInstructions" in swap_instructions_data and swap_instructions_data["setupInstructions"]:
+                instructions += TradeManager.parse_instruction_list(swap_instructions_data["setupInstructions"])
+
+            # 3. Fee instruction (if wallet.fee_payer)
+            if wallet.fee_payer:
+                if input_mint == "So11111111111111111111111111111111111111112":
+                    ix_fee = transfer(
+                        TransferParams(
+                            from_pubkey=wallet.pubkey,
+                            to_pubkey=wallet.fee_payer.pubkey(),
+                            lamports=int(input_amount * LAMPORTS_PER_SOL * (fee_percentage / 100)),
+                        )
+                    )
+                else:
+                    mint_pubkey = Pubkey.from_string(input_mint)
+                    resp = await wallet.client.get_account_info(mint_pubkey)
+                    owner = str(resp.value.owner)
+                    if owner == SPL_TOKEN_PROGRAM_ID:
+                        program_id = Pubkey.from_string(SPL_TOKEN_PROGRAM_ID)
+                    elif owner == TOKEN_2022_PROGRAM_ID:
+                        program_id = Pubkey.from_string(TOKEN_2022_PROGRAM_ID)
+                    else:
+                        raise ValueError(
+                            f"Unsupported token program: {owner}. Supported programs are SPL Token and Token 2022."
+                        )
+
+                    token = AsyncToken(
+                        wallet.client, mint_pubkey, program_id, wallet.fee_payer
+                    )
+
+                    from_ata = (
+                        (await token.get_accounts_by_owner(wallet.pubkey)).value[0].pubkey
+                    )
+                    mint_info = await token.get_mint_info()
+                    adjusted_amount = int(input_amount * (10**mint_info.decimals))
+
+                    to_fee_ata = (await token.get_accounts_by_owner(wallet.fee_payer.pubkey())).value[0].pubkey
+                    fee_amount = int(adjusted_amount * (fee_percentage / 100))
+                    ix_fee = spl_transfer(
+                        SPLTransferParams(
+                            program_id=program_id,
+                            source=from_ata,
+                            mint=mint_pubkey,
+                            dest=to_fee_ata,
+                            owner=wallet.pubkey,
+                            amount=fee_amount,
+                            decimals=mint_info.decimals,
+                        )
+                    )
+                    instructions.append(ix_fee)
+
+            # 4. Swap instruction (required)
+            swap_instruction = TradeManager.parse_instruction(swap_instructions_data["swapInstruction"])
+            instructions.append(swap_instruction)
+
+            # 5. Cleanup instruction (if present)
+            if "cleanupInstruction" in swap_instructions_data and swap_instructions_data["cleanupInstruction"]:
+                instructions.append(TradeManager.parse_instruction(swap_instructions_data["cleanupInstruction"]))
+
+            # 6. Other instructions (if present)
+            if "otherInstructions" in swap_instructions_data and swap_instructions_data["otherInstructions"]:
+                instructions += TradeManager.parse_instruction_list(swap_instructions_data["otherInstructions"])
+
+            # Address lookup tables
+            address_table_lookups = TradeManager.parse_address_table_lookups(
+                swap_instructions_data.get("addressLookupTableAddresses", [])
+            )
+
+            # Simulate to estimate compute units (only if Jupiter did NOT provide CU instructions)
+            if not has_cu:
+                blockhash_response = await wallet.client.get_latest_blockhash(commitment=Finalized)
+                recent_blockhash = blockhash_response.value.blockhash
+
+                msg = MessageV0.try_compile(
+                    wallet.pubkey,
+                    instructions,
+                    [],
+                    recent_blockhash,
                 )
-                return signed_transaction
+                transaction = VersionedTransaction.populate(msg, [Signature.default()])
+                cu_units = (
+                    await wallet.client.simulate_transaction(
+                        transaction, sig_verify=False
+                    )
+                ).value.units_consumed or 1_400_000
 
-            signature = wallet.sign_message(to_bytes_versioned(transaction.message))
-            signed_transaction = VersionedTransaction.populate(
-                transaction.message, [signature]
+                compute_budget_ix = set_compute_unit_limit(int(cu_units + 100_000))
+
+                # Priority fee (helius)
+                priority_fee_ix = None
+                if provider == "helius":
+                    priority_fee = swap_instructions_data.get("prioritizationFeeLamports", 0)
+                    if priority_fee and priority_fee > 0:
+                        priority_fee_ix = set_compute_unit_price(priority_fee)
+
+                # Insert compute budget and priority fee at the start
+                instructions_with_cu = [compute_budget_ix]
+                if priority_fee_ix:
+                    instructions_with_cu.append(priority_fee_ix)
+                instructions_with_cu += instructions
+            else:
+                instructions_with_cu = instructions
+
+            # Re-compile with compute budget and priority fee, now with address_table_lookups
+            blockhash_response = await wallet.client.get_latest_blockhash(commitment=Finalized)
+            recent_blockhash = blockhash_response.value.blockhash
+
+            msg_final = MessageV0.try_compile(
+                wallet.pubkey,
+                instructions_with_cu,
+                address_table_lookups,
+                recent_blockhash,
             )
 
+            # Sign and return the transaction
+            if no_signer:
+                signature = NullSigner(wallet.pubkey).sign_message(to_bytes_versioned(msg_final))
+                signed_transaction = VersionedTransaction.populate(msg_final, [signature])
+                return signed_transaction
+
+            signature = wallet.sign_message(to_bytes_versioned(msg_final))
+            signed_transaction = VersionedTransaction.populate(msg_final, [signature])
             return signed_transaction
 
         except Exception as e:
             logging.exception(f"Swap failed: {str(e)}")
-            raise Exception(f"Swap failed: {str(e)}")
+            raise Exception(f"Swap failed: {str(e)}")