Multiply Deposit with KSwap

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  address,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
  none,
  compressTransactionMessageUsingAddressLookupTables,
} from '@solana/kit';
import {
  KaminoMarket,
  MultiplyObligation,
  PROGRAM_ID,
  parseKeypairFile,
  getDepositWithLeverageIxs,
  getUserLutAddressAndSetupIxs,
  getScopeRefreshIxForObligationAndReserves,
  getComputeBudgetAndPriorityFeeIxs,
  ObligationTypeTag,
  simulateTx,
} from '@kamino-finance/klend-sdk';
import { KswapSdk } from '@kamino-finance/kswap-sdk';
import { Scope } from '@kamino-finance/scope-sdk';
import { Connection } from '@solana/web3.js';
import Decimal from 'decimal.js';

const KEYPAIR_FILE = '/path/to/your/keypair.json';
const CDN_ENDPOINT = 'https://cdn.kamino.finance';

const signer = await parseKeypairFile(KEYPAIR_FILE);

const rpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');
const connection = new Connection('https://api.mainnet-beta.solana.com');

// JLP Market configuration
const marketPubkey = address('DxXdAyU3kCjnyggvHmY5nAwg5cRbbmdyX3npfDMjjMek');
const collTokenMint = address('27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4'); // JLP
const debtTokenMint = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'); // USDC

const market = await KaminoMarket.load(rpc, marketPubkey, 100);
const scope = new Scope('mainnet-beta', rpc);
const kswapSdk = new KswapSdk('https://api.kamino.finance/kswap', connection);

const kaminoResourcesResponse = await fetch(`${CDN_ENDPOINT}/resources.json`);
const kaminoResourcesData = await kaminoResourcesResponse.json();
const kaminoResources = kaminoResourcesData['mainnet-beta'];
const multiplyColPairs = kaminoResources.multiplyLUTsPairs[collTokenMint] || {};
const multiplyLut = multiplyColPairs[debtTokenMint] || [];
const multiplyLutKeys = multiplyLut.map((lut: string) => address(lut));

const depositAmount = new Decimal(1); // $1 USDC
const leverage = 3; // 3x leverage
const slippageBps = 30; // 0.3% slippage tolerance

const multiplyMints: { coll: Address; debt: Address }[] = [
  { coll: collTokenMint, debt: debtTokenMint }
];
const leverageMints: { coll: Address; debt: Address }[] = [];

const [userLookupTable, setupTxsIxs] = await getUserLutAddressAndSetupIxs(
  market,
  signer,
  none(),
  true,
  multiplyMints,
  leverageMints
);

// Execute setup transactions if needed
for (const setupIxs of setupTxsIxs) {
  const { value: setupBlockhash } = await rpc
    .getLatestBlockhash({ commitment: 'finalized' })
    .send();

  const setupTx = pipe(
    createTransactionMessage({ version: 0 }),
    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
    (tx) => setTransactionMessageLifetimeUsingBlockhash(setupBlockhash, tx),
    (tx) => appendTransactionMessageInstructions(setupIxs, tx)
  );

  const signedSetupTx = await signTransactionMessageWithSigners(setupTx);

  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
    signedSetupTx,
    { commitment: 'confirmed', skipPreflight: true }
  );

  await new Promise((resolve) => setTimeout(resolve, 2000));
}

const currentSlot = await rpc.getSlot().send();
const collTokenReserve = market.getReserveByMint(collTokenMint)!;
const debtTokenReserve = market.getReserveByMint(debtTokenMint)!;

const obligationType = new MultiplyObligation(
  collTokenMint,
  debtTokenMint,
  PROGRAM_ID
);
const obligationAddress = await obligationType.toPda(
  market.getAddress(),
  signer.address
);
const obligation = await market.getObligationByAddress(obligationAddress);

const scopeConfiguration = {
  scope,
  scopeConfigurations: await scope.getAllConfigurations()
};

const scopeRefreshIx = await getScopeRefreshIxForObligationAndReserves(
  market,
  collTokenReserve,
  debtTokenReserve,
  obligation,
  scopeConfiguration
);

import { getKswapQuoter, getKswapSwapper, getTokenPriceFromJupWithFallback } from './kswap_utils';

const priceDebtToColl = new Decimal(
  await getTokenPriceFromJupWithFallback(kswapSdk, debtTokenMint, collTokenMint)
);

const computeIxs = getComputeBudgetAndPriorityFeeIxs(1_400_000, new Decimal(500000));

const depositWithLeverageRoutes = await getDepositWithLeverageIxs({
  owner: signer,
  kaminoMarket: market,
  debtTokenMint: debtTokenMint,
  collTokenMint: collTokenMint,
  depositAmount: depositAmount,
  priceDebtToColl: priceDebtToColl,
  slippagePct: new Decimal(slippageBps / 100),
  obligation: obligation || null,
  referrer: none(),
  currentSlot,
  targetLeverage: new Decimal(leverage),
  selectedTokenMint: debtTokenMint,
  obligationTypeTagOverride: ObligationTypeTag.Multiply,
  scopeRefreshIx,
  budgetAndPriorityFeeIxs: computeIxs,
  quoteBufferBps: new Decimal(1000),
  quoter: getKswapQuoter(kswapSdk, signer.address, slippageBps, debtTokenReserve, collTokenReserve),
  swapper: getKswapSwapper(kswapSdk, signer.address, slippageBps),
  useV2Ixs: true,
});

import { fetchAllAddressLookupTable } from '@solana-program/address-lookup-table';

const JLP_MARKET_LUT = address('GprZNyWk67655JhX6Rq9KoebQ6WkQYRhATWzkx2P2LNc');
const klendLookupTableKeys = [userLookupTable, ...multiplyLutKeys, JLP_MARKET_LUT];
const klendLutAccounts = await fetchAllAddressLookupTable(rpc, klendLookupTableKeys);

const simulationResults = await Promise.all(
  depositWithLeverageRoutes.map(async (route) => {
    const lookupTables = [...route.lookupTables, ...klendLutAccounts];

    const simulation = await simulateTx(
      rpc,
      signer.address,
      route.ixs,
      lookupTables
    ).catch(() => undefined);

    if (!simulation || simulation.value.err) {
      return undefined;
    }

    return {
      ixs: route.ixs,
      luts: lookupTables.map((l) => l.address),
      routeOutput: route.quote!,
      swapInputs: route.swapInputs,
    };
  })
);

const passingSimulations = simulationResults.filter((tx) => tx !== undefined);

const bestRoute = passingSimulations.length > 0
  ? passingSimulations.reduce((best, current) => {
      const inputMintReserve = market.getReserveByMint(best.swapInputs.inputMint)!;
      const outputMintReserve = market.getReserveByMint(best.swapInputs.outputMint)!;

      const bestPrice = new Decimal(best.routeOutput.amountsExactIn.amountOutGuaranteed.toString())
        .div(outputMintReserve.getMintFactor())
        .div(new Decimal(best.routeOutput.amountsExactIn.amountIn.toString())
        .div(inputMintReserve.getMintFactor()));

      const currentPrice = new Decimal(current.routeOutput.amountsExactIn.amountOutGuaranteed.toString())
        .div(outputMintReserve.getMintFactor())
        .div(new Decimal(current.routeOutput.amountsExactIn.amountIn.toString())
        .div(inputMintReserve.getMintFactor()));

      return bestPrice.greaterThan(currentPrice) ? best : current;
    })
  : (() => {
      const lookupTables = [...depositWithLeverageRoutes[0].lookupTables, ...klendLutAccounts];
      return {
        ixs: depositWithLeverageRoutes[0].ixs,
        luts: lookupTables.map((l) => l.address)
      };
    })();

await new Promise((resolve) => setTimeout(resolve, 2000));

const { value: latestBlockhash } = await rpc
  .getLatestBlockhash({ commitment: 'finalized' })
  .send();

// Prepare LUT addresses for compression
const lutsByAddress: Record<Address, Address[]> = {};
const bestRouteLutAccounts = await fetchAllAddressLookupTable(rpc, bestRoute.luts || []);
for (const acc of bestRouteLutAccounts) {
  lutsByAddress[acc.address] = acc.data.addresses;
}

// Build transaction with LUT compression
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => appendTransactionMessageInstructions(bestRoute.ixs, tx),
  (tx) => setTransactionMessageFeePayerSigner(signer, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
  (tx) => compressTransactionMessageUsingAddressLookupTables(tx, lutsByAddress)
);

const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
const signature = getSignatureFromTransaction(signedTransaction);

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
  signedTransaction,
  {
    commitment: 'processed',
    preflightCommitment: 'processed',
    skipPreflight: true,
  }
);

console.log('Multiply deposit successful! Signature:', signature);
console.log(`Position: ~${depositAmount.mul(leverage)} JLP with ${depositAmount.mul(leverage - 1)} USDC debt`);