Lend Referral SDK

npm install @jup-ag/lend-referral-sdk @solana/kit

resolveWrapper(rpc, { jlTokenMint, lending, xTokenMint })   read: 2 RPC round trips, one validated snapshot
  └─ ctx: WrapperContext
depositUnderlying(ctx, { user, underlyingAmount, bound })  act: no RPC call
  └─ { instructions, quote }
buildTransactionMessage(rpc, { feePayer, instructions })   sign and send: your pipeline
  ├─ signTransactionMessageWithSigners(message)
  └─ sendAndConfirmTransactionFactory(...)(signed)
       └─ on failure: decodeProgramError(err, message)      name the Lend Referral error

import { address, type Address, createSolanaRpc, isSome, unwrapOption } from "@solana/kit";
import { findLendingAddress, resolveWrapper } from "@jup-ag/lend-referral-sdk";

// The wrapper's xToken mint. Jupiter sends it when it creates your wrapper.
declare const xTokenMint: Address;

const USDC = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const JLUSDC = address("9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D");

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
const lending = await findLendingAddress({ underlyingMint: USDC, jlTokenMint: JLUSDC });

const ctx = await resolveWrapper(rpc, { jlTokenMint: JLUSDC, lending, xTokenMint });

const { data } = ctx.wrapper;
const share = data.protocolFeeShareOverride;
console.log({
  partnerFeeBps: data.partnerFeeBps,
  protocolShareBps: isSome(share) ? share.value : ctx.protocol.data.protocolFeeShareBps,
  claimAuthority: unwrapOption(data.claimAuthority), // Address | null
  paused: ctx.protocol.data.paused,
  decimals: ctx.lending.data.decimals,
  tokenProgram: ctx.tokenProgram,
  vaultBalance: ctx.vaultBalance, // jlToken atoms in the vault
});

import {
  address,
  type Address,
  assertIsTransactionWithBlockhashLifetime,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  getSignatureFromTransaction,
  sendAndConfirmTransactionFactory,
  signTransactionMessageWithSigners,
} from "@solana/kit";
import {
  buildTransactionMessage,
  decodeProgramError,
  depositUnderlying,
  findLendingAddress,
  ReferralSdkError,
  resolveWrapper,
} from "@jup-ag/lend-referral-sdk";

// The wallet's 64-byte secret key, loaded from your secret store.
declare const secretKey: Uint8Array;
// The wrapper's xToken mint. Jupiter sends it when it creates your wrapper.
declare const xTokenMint: Address;

const USDC = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const JLUSDC = address("9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D");

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.mainnet-beta.solana.com");
const user = await createKeyPairSignerFromBytes(secretKey);

// 1. Read: one validated snapshot of the wrapper and its market.
const lending = await findLendingAddress({ underlyingMint: USDC, jlTokenMint: JLUSDC });
const ctx = await resolveWrapper(rpc, { jlTokenMint: JLUSDC, lending, xTokenMint });
if (ctx.protocol.data.paused) throw new Error("Lend Referral is paused");

// 2. Act: instructions plus the estimate behind the bound. No RPC call.
let built;
try {
  built = await depositUnderlying(ctx, {
    user,
    underlyingAmount: 1_000_000n, // 1 USDC
    bound: { slippageBps: 50 },
  });
} catch (err) {
  if (err instanceof ReferralSdkError && err.kind === "AmountTooSmall") {
    throw new Error("Deposit at least 10 atoms of the underlying token");
  }
  throw err;
}
console.log(`Expect ${built.quote.xOut} xToken atoms, at least ${built.quote.minXOut}`);

// 3. Sign and send.
const message = await buildTransactionMessage(rpc, {
  feePayer: user,
  instructions: built.instructions,
});
const signed = await signTransactionMessageWithSigners(message);
assertIsTransactionWithBlockhashLifetime(signed);
try {
  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signed, { commitment: "confirmed" });
  console.log("Deposited:", getSignatureFromTransaction(signed));
} catch (err) {
  const decoded = decodeProgramError(err, message);
  if (decoded?.name === "WrapperSlippageExceeded") {
    // The rate moved past the bound. Read again and rebuild.
  }
  console.error(decoded ?? err);
  throw err;
}

import {
  createSolanaRpc,
  getSolanaErrorFromTransactionError,
  type Instruction,
  type TransactionSigner,
} from "@solana/kit";
import { buildTransactionMessage, decodeProgramError, simulateMessage } from "@jup-ag/lend-referral-sdk";

// The fee payer and the instructions from an action.
declare const feePayer: TransactionSigner;
declare const instructions: Instruction[];

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

// Simulate once to measure the compute units.
const draft = await buildTransactionMessage(rpc, { feePayer, instructions });
const { value } = await simulateMessage(rpc, draft);
if (value.err) {
  const decoded = decodeProgramError(getSolanaErrorFromTransactionError(value.err), draft);
  console.error(decoded?.name ?? value.err, value.logs);
  throw new Error("Simulation failed");
}

// Rebuild with a limit 10% above the measured units and a priority fee.
const units = Number(value.unitsConsumed ?? 200_000n);
const message = await buildTransactionMessage(rpc, {
  feePayer,
  instructions,
  computeUnitLimit: Math.ceil(units * 1.1),
  computeUnitPriceMicroLamports: 10_000n, // read recent fees with getRecentPrioritizationFees
});
console.log(`Simulated ${units} compute units`);

import { type TransactionSigner } from "@solana/kit";
import {
  buildTransactionMessage,
  decodeProgramError,
  depositUnderlying,
  type ReferralMessage,
  type ReferralRpc,
  ReferralSdkError,
  resolveWrapper,
  type TxRpc,
  type WrapperRef,
} from "@jup-ag/lend-referral-sdk";

// Your RPC client, the wrapper reference (see "Read a wrapper"), and the user's signer.
declare const rpc: ReferralRpc & TxRpc;
declare const ref: WrapperRef;
declare const user: TransactionSigner;
// Your own sign-and-send step. Returns the transaction signature.
declare function signAndSend(message: ReferralMessage): Promise<string>;

let message: ReferralMessage;
try {
  const ctx = await resolveWrapper(rpc, ref);
  const { instructions } = await depositUnderlying(ctx, {
    user,
    underlyingAmount: 1_000_000n,
    bound: { slippageBps: 50 },
  });
  message = await buildTransactionMessage(rpc, { feePayer: user, instructions });
} catch (err) {
  if (err instanceof ReferralSdkError) {
    // Raised before anything is sent. err.kind says which check failed.
    console.error(err.kind, err.message, err.context);
  }
  throw err;
}

try {
  console.log(await signAndSend(message));
} catch (err) {
  const decoded = decodeProgramError(err, message);
  switch (decoded?.name) {
    case "WrapperSlippageExceeded":
      // Read again, rebuild with a fresh quote, and ask the user to confirm.
      break;
    case "ProtocolPaused":
      // Every deposit, redeem and withdrawal is blocked until Jupiter unpauses.
      break;
    default:
      console.error(decoded ?? err);
  }
  throw err;
}