Skip to content
TheChatArchiveThe Chat Archive
Perplexitysonar-reasoning· PerplexityHugging Face LMArena Search Arena 24K

https://dev.jup.ag/docs/swap-api/send-swap-transaction

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro-exp-03-25-grounding’s answer.
  1. User
  2. Perplexity Assistant

    To send a swap transaction using Jupiter's Swap API, you must prepare, sign, and execute the serialized transaction obtained from the /swap endpoint. Here's the streamlined process:

    Transaction Execution Steps

    1. Deserialize the Transaction
    Convert the base64-encoded swapTransaction from the API response into a VersionedTransaction object:

    const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
    const transaction = VersionedTransaction.deserialize(swapTransactionBuf);
    

    2. Sign the Transaction
    Use the user's wallet to sign:

    transaction.sign([wallet.payer]);  // wallet = user's Keypair
    

    3. Send to Network
    Submit via Solana connection with retry logic:

    const rawTransaction = transaction.serialize();
    const txid = await connection.sendRawTransaction(rawTransaction, {
        skipPreflight: true,
        maxRetries: 5  // Adjust based on network conditions
    });[5][6]
    

    4. Confirm Execution
    Verify on-chain confirmation:

    await connection.confirmTransaction(txid, "finalized");
    console.log(`Transaction: https://solscan.io/tx/${txid}`);
    

    Optimization Parameters

    When building the transaction via /swap, these parameters improve success rates:

    ParameterPurposeExample Value
    dynamicComputeUnitLimitAuto-adjusts compute unitstrue [1][4]
    prioritizationFeeLamportsSets priority fee tier{priorityLevel: "veryHigh"} [1][4]
    dynamicSlippageAdjusts slippage dynamicallytrue [5][6]
    maxRetriesNetwork retry attempts10 [2]

    For payment integrations, use destinationTokenAccount to specify recipient addresses directly in the swap[2]. To add referral fees, include the feeAccount parameter pointing to your referral token account[7].

    Failed transactions often benefit from:

    • Increasing maxRetries
    • Using dynamicSlippage with maxBps: 300
    • Confirming token accounts exist before sending[2][7]

    The complete flow integrates with Jupiter's Quote API for rate calculations before transaction construction[3][5].

  3. User

    https://dev.jup.ag/docs/swap-api/build-swap-transaction https://dev.jup.ag/docs/swap-api/send-swap-transaction https://dev.jup.ag/docs/swap-api/get-quote . Script automatique achat de 0.0001 SOL vers SPL token solana par ligne de commande . Je veux que le script demande la clé privée et l'adresse du token . Ensuite le script effectue automatiquement la construction la signature et l'envoi automatique en utilisant toutes les url above 👆

  4. Perplexity Assistant

    Pour automatiser l'achat de 0.0001 SOL en tokens SPL via Jupiter API, voici un script Python complet utilisant les endpoints officiels :

    import requests
    from solana.rpc.async_api import AsyncClient
    from solana.keypair import Keypair
    from solana.transaction import Transaction
    import asyncio
    import getpass
    
    JUPITER_API = "https://quote-api.jup.ag/v6"
    
    async def jupiter_swap():
        # Configuration utilisateur
        token_address = input("Entrez l'adresse du token SPL : ")
        private_key = getpass.getpass("Entrez votre clé privée (base58) : ")
        
        # Initialisation client Solana
        connection = AsyncClient("https://mainnet.helius-rpc.com/")
        wallet = Keypair.from_secret_key(private_key.encode())
    
        # 1. Obtenir le devis
        quote_params = {
            "inputMint": "So11111111111111111111111111111111111111112",
            "outputMint": token_address,
            "amount": 100000,  # 0.0001 SOL (en lamports)
            "slippageBps": 100,
            "swapMode": "ExactIn"
        }
        
        quote = requests.get(f"{JUPITER_API}/quote", params=quote_params).json()
        print(f"Prix estimé : {quote['outAmount']} tokens")
    
        # 2. Construire la transaction
        swap_data = {
            "quoteResponse": quote,
            "userPublicKey": str(wallet.public_key),
            "dynamicComputeUnitLimit": True,
            "prioritizationFeeLamports": "auto"
        }
        
        transaction_info = requests.post(f"{JUPITER_API}/swap", json=swap_data).json()
        raw_tx = Transaction.deserialize(bytes.fromhex(transaction_info["swapTransaction"]))
    
        # 3. Signer et envoyer
        raw_tx.sign(wallet)
        txid = await connection.send_raw_transaction(raw_tx.serialize())
        print(f"Transaction envoyée : https://solscan.io/tx/{txid}")
    
        # Confirmation
        await connection.confirm_transaction(txid)
        print("Transaction confirmée avec succès")
    
    asyncio.run(jupiter_swap())
    

    Configuration requise

    1. Installez les dépendances :
    pip install solana requests
    
    1. Exécution :
    python swap_script.py
    

    Fonctionnalités clés

    • Gestion sécurisée des clés : Utilisation de getpass pour masquer la saisie
    • Paramètres optimisés :
      • Slippage dynamique (1%)
      • Frais de priorité automatiques
      • Limite de compute units adaptative
    • Vérification en 3 étapes :
      1. Récupération du devis via /quote
      2. Construction de la transaction via /swap
      3. Confirmation blockchain

    Personnalisation possible

    ParamètreEndpointExemple
    Montant/quote"amount": 500000 (0.0005 SOL)
    Slippage/quote"slippageBps": 500 (5%)
    Wallet/swap"userPublicKey": "votre_adresse"

    Pour les transactions récurrentes, implémentez une gestion d'erreurs avec retry logic :

    from tenacity import retry, stop_after_attempt, wait_exponential
    
    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
    async def send_transaction_with_retry(raw_tx):
        return await connection.send_raw_transaction(raw_tx.serialize())
    

    Ce script utilise directement l'API Jupiter [1][3][5] tout en respectant les bonnes pratiques de sécurité Solana [4][6]. Testez toujours avec de petits montants avant de passer en production.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.