tokenIn: string; // public key of the token you are providing
tokenOut: string; // public key of the token you want to swap for
action: Action; // Set to 'exactIn' or 'exactOut'
amount: string; // Amount specified in Lamports
slippageBps?: number; // Slippage Basis Points. Optional.
maxHops?: number; // Optional.
exemptFees?: boolean; // Optional.

type GetQuoteResponse = {
  aggregatorFee: string; // u64 as string
  slot: string; // u64 as string
  timestamp: string; // u64 as string
  path: GenericQuote[]; // Vec of quotes
  minAmountOutOrMaxIn: string; // u64 as string
};

type GenericQuote = {
  pool: string;
  swapContext: any; // This might need a more specific type depending on your needs
  direction: string;
  amountIn: string; // u64 as string
  amountOut: string; // u64 as string
  feeTaken: string; // u64 as string
  token0Impact: string; // Bps as decimal string
  token1Impact: string; // Bps as decimal string
};

tokenIn: string; // public key of the token you are providing
tokenOut: string; // public key of the token you want to swap for
action: Action; // set to 'exactIn' or 'exactOut'
amount: string; // amount in Lamports
userPubkey: string; // public key of your wallet
maxHops?: number; // optional since it has a default
slippageBps?: number; // optional since it has a default

txn: string; // this is the versioned transaction

// Import the libraries we need
import { Connection, VersionedTransaction } from "@solana/web3.js";
import bs58 from "bs58";

// Assume you already have these variables set up
conn = // this is a connection to your RPC
  versionedTxn = // this is the versioned transaction returned from the Swap API that you want to execute
  // Deserialize the transaction
  txn =
    VersionedTransaction.deserialize(bs58.decode(versionedTxn));

// Sign the transaction with your wallet
txn.sign([keyPair]);

// Simulate the transation
const sim = await conn.simulateTransaction(txn);

// If there are any problems, bail out
if (sim.value.err) {
  console.error(sim.value.err);
  console.error(sim.value.logs);
  throw new Error("Transaction Sim Response resulted in error");
}

// Send the transaction!
await conn.sendRawTransaction(txn.serialize());

import { createJupiterApiClient } from "@jup-ag/api";
import { inspect } from "util";

const main = async () => {
  const jupiter = createJupiterApiClient({
    basePath: "https://raging-river.hellomoon.io/api/jup",
    headers: {
      Authorization: "Bearer hf0e87h7ewh98",
    },
  });

  const quote = await jupiter.quoteGet({
    inputMint: "So11111111111111111111111111111111111111112", // SOL
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
    amount: 100000000, // 0.1 SOL (100000000 lamports)
    slippageBps: 100, // 1% slippage tolerance
  });

  console.log(inspect(quote));
};

if (require.main === module) {
  main().catch(console.error);
}

import { createJupiterApiClient } from "@jup-ag/api";
import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js";
import bs58 from "bs58";
import { inspect } from "util";

// Replace with your actual private key
const BS58_PRIVATE_KEY = "YOUR_PRIVATE_KEY";

const main = async () => {
  // Initialize Jupiter API client
  const jupiter = createJupiterApiClient({
    basePath: "https://raging-river.hellomoon.io/api/jup",
    headers: {
      Authorization: "Bearer hf0e87h7ewh98",
    },
  });

  // Step 1: Get a quote
  const quote = await jupiter.quoteGet({
    inputMint: "So11111111111111111111111111111111111111112", // SOL
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
    amount: 100000000, // 0.1 SOL (100000000 lamports)
    slippageBps: 100, // 1% slippage tolerance
  });

  console.log("Quote obtained:", inspect(quote, { depth: null }));

  // Step 2: Create a wallet for transaction (replace with your actual wallet)
  // Note: In production, use a more secure way to handle private keys
  const privateKey = bs58.decode(BS58_PRIVATE_KEY);
  const wallet = Keypair.fromSecretKey(privateKey);

  // Step 3: Connect to Solana
  const connection = new Connection(
    "https://raging-river.hellomoon.io/hf0e87h7ewh98",
    "confirmed",
  );

  // Step 4: Create the swap transaction
  const swapTransaction = await jupiter.swapPost({
    swapRequest: {
      quoteResponse: quote,
      userPublicKey: wallet.publicKey.toString(),
    },
  });

  console.log(
    "Swap transaction created:",
    inspect(swapTransaction, { depth: null }),
  );

  // Step 5: Deserialize the transaction
  const swapTransactionBuf = Buffer.from(
    swapTransaction.swapTransaction,
    "base64",
  );
  const transaction = VersionedTransaction.deserialize(swapTransactionBuf);

  // Step 6: Sign the transaction
  transaction.sign([wallet]);

  // Step 7: Execute the transaction
  const signature = await connection.sendTransaction(transaction);
  console.log("Transaction submitted:", signature);

  // Step 8: Confirm the transaction
  const confirmation = await connection.confirmTransaction(
    signature,
    "confirmed",
  );
  console.log("Transaction confirmed:", confirmation);
};

if (require.main === module) {
  main().catch(console.error);
}