Landing Raydium and Jupiter swaps

1import {
2  AddressLookupTableProgram, Connection, Keypair, PublicKey,
3  TransactionMessage, VersionedTransaction,
4} from "@solana/web3.js";
5 
6/**
7 * Address lookup tables are the difference between a route that fits in a
8 * transaction and one that does not.
9 *
10 * A transaction is capped at 1,232 bytes. Every account referenced costs 32
11 * bytes inline. A two-hop Jupiter route can reference 30 or more accounts,
12 * which is nearly a kilobyte before you have added a single instruction.
13 *
14 * A lookup table replaces each 32-byte key with a 1-byte index. On a route
15 * with 30 accounts that is roughly 930 bytes reclaimed.
16 */
17export async function createLookupTable(
18  rpc: Connection,
19  payer: Keypair,
20  addresses: PublicKey[],
21) {
22  const slot = await rpc.getSlot("finalized");
23 
24  const [createIx, tableAddress] = AddressLookupTableProgram.createLookupTable({
25    authority: payer.publicKey,
26    payer: payer.publicKey,
27    recentSlot: slot,
28  });
29 
30  // Extending is capped at roughly 30 addresses per instruction, so a large
31  // table needs several transactions.
32  const chunks: PublicKey[][] = [];
33  for (let i = 0; i < addresses.length; i += 30) chunks.push(addresses.slice(i, i + 30));
34 
35  const extendIxs = chunks.map((chunk) =>
36    AddressLookupTableProgram.extendLookupTable({
37      payer: payer.publicKey,
38      authority: payer.publicKey,
39      lookupTable: tableAddress,
40      addresses: chunk,
41    }),
42  );
43 
44  return { createIx, extendIxs, tableAddress };
45}
46 
47/**
48 * A table is only usable one slot after the transaction that extended it
49 * lands. Build it well ahead of when you need it, not in the same breath.
50 */
51export async function loadTable(rpc: Connection, address: PublicKey) {
52  const { value } = await rpc.getAddressLookupTable(address);
53  if (!value) throw new Error("lookup table not found or not yet active");
54  return value;
55}

1import { Connection, PublicKey } from "@solana/web3.js";
2 
3/**
4 * Slippage tolerance is a risk decision, and treating it as a constant is how
5 * people lose money slowly.
6 *
7 * Too tight and you fail on chain, having paid the fee, and you retry into a
8 * market that has already moved. Too loose and you are handing a sandwich
9 * attacker a guaranteed profit: your maxSlippage IS their profit ceiling, and
10 * they will take exactly that much.
11 *
12 * The right tolerance comes from the volatility of the pair and the depth of
13 * the pool, not from a settings file.
14 */
15export function toleranceBps(opts: {
16  recentVolatilityBps: number;   // realised move over your expected latency
17  poolDepthUsd: number;
18  tradeSizeUsd: number;
19  competitive: boolean;          // are you racing anyone for this fill?
20}): number {
21  // Price impact from your own size against the pool.
22  const impactBps = (opts.tradeSizeUsd / opts.poolDepthUsd) * 10_000;
23 
24  // Cover your own impact, plus the market moving while you are in flight.
25  const base = impactBps + opts.recentVolatilityBps;
26 
27  // In a race, failing is worse than paying a little more. Outside a race,
28  // there is no reason to widen the target on your own back.
29  const margin = opts.competitive ? 1.5 : 1.15;
30 
31  // The cap is not arbitrary: past a few percent you are underwriting an
32  // attacker rather than tolerating market movement.
33  return Math.min(500, Math.ceil(base * margin));
34}
35 
36/** Turn basis points into the minimum-out figure the program wants. */
37export function minimumOut(quotedOut: bigint, bps: number): bigint {
38  return (quotedOut * BigInt(10_000 - bps)) / 10_000n;
39}

1/**
2 * Jupiter's quote endpoint, with the parameters that matter for landing rather
3 * than for the headline price.
4 */
5export async function quote(params: {
6  inputMint: string;
7  outputMint: string;
8  amount: bigint;
9  slippageBps: number;
10}) {
11  const url = new URL("https://quote-api.jup.ag/v6/quote");
12  url.searchParams.set("inputMint", params.inputMint);
13  url.searchParams.set("outputMint", params.outputMint);
14  url.searchParams.set("amount", params.amount.toString());
15  url.searchParams.set("slippageBps", String(params.slippageBps));
16 
17  // Each of these trades a little price for a lot of reliability.
18  //
19  // maxAccounts caps how many accounts the route may touch, which directly
20  // caps transaction size and compute. Left unbounded, the best-priced route
21  // is often one that will not fit or will not land.
22  url.searchParams.set("maxAccounts", "40");
23 
24  // Direct routes only, when you are racing. A two-hop route quoting 0.1%
25  // better is worse than a direct route that lands.
26  url.searchParams.set("onlyDirectRoutes", "false");
27 
28  // Intermediate tokens add hops, accounts and failure modes.
29  url.searchParams.set("restrictIntermediateTokens", "true");
30 
31  const res = await fetch(url, { signal: AbortSignal.timeout(2_000) });
32  if (!res.ok) throw new Error(`quote failed: ${res.status}`);
33  return res.json();
34}
35 
36/**
37 * Build the swap transaction. Ask for the transaction, then take over the
38 * compute budget and the sending yourself: the defaults are tuned for a
39 * generic wallet, not for a sender that has measured anything.
40 */
41export async function buildSwap(quoteResponse: unknown, userPublicKey: string) {
42  const res = await fetch("https://quote-api.jup.ag/v6/swap", {
43    method: "POST",
44    headers: { "Content-Type": "application/json" },
45    body: JSON.stringify({
46      quoteResponse,
47      userPublicKey,
48      wrapAndUnwrapSol: true,
49      // We set our own budget from measured figures.
50      dynamicComputeUnitLimit: false,
51      prioritizationFeeLamports: 0,
52      asLegacyTransaction: false,   // v0 so lookup tables work
53    }),
54    signal: AbortSignal.timeout(3_000),
55  });
56 
57  if (!res.ok) throw new Error(`swap build failed: ${res.status}`);
58  const { swapTransaction } = await res.json();
59  return Buffer.from(swapTransaction, "base64");
60}