Transaction Versions (v0 and v1)

import {
  AccountRole,
  Address,
  appendTransactionMessageInstructions,
  Blockhash,
  compileTransaction,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createTransactionMessage,
  getBase58Decoder,
  getBase58Encoder,
  getBase64Codec,
  getBase64EncodedWireTransaction,
  pipe,
  setTransactionMessageConfig,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
} from "@solana/kit";

const API_KEY = process.env.JUPITER_API_KEY;
const RPC_URL = process.env.RPC_URL;
if (!API_KEY) throw new Error("Missing JUPITER_API_KEY");
if (!RPC_URL) throw new Error("Missing RPC_URL");

const COMPUTE_UNIT_LIMIT_MAX = 1_400_000;
// v1 has no default loaded-accounts-data-size limit (unset budgets zero bytes).
// 64 MiB matches the implicit v0 default.
const LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 64 * 1024 * 1024;

const signer = await createKeyPairSignerFromBytes(
  getBase58Encoder().encode(process.env.BS58_PRIVATE_KEY!),
);
const rpc = createSolanaRpc(RPC_URL);

type ApiInstruction = {
  programId: Address;
  accounts: { pubkey: Address; isSigner: boolean; isWritable: boolean }[];
  data: string;
};

type BuildResponse = {
  computeUnitPrice: string;
  setupInstructions: ApiInstruction[];
  swapInstruction: ApiInstruction;
  cleanupInstruction: ApiInstruction | null;
  otherInstructions: ApiInstruction[];
  tipInstruction: ApiInstruction | null;
  blockhashWithMetadata: { blockhash: number[]; lastValidBlockHeight: number };
};

function toInstruction(ix: ApiInstruction) {
  return {
    programAddress: ix.programId,
    accounts: ix.accounts.map((a) => ({
      address: a.pubkey,
      role:
        a.isSigner && a.isWritable
          ? AccountRole.WRITABLE_SIGNER
          : a.isSigner
            ? AccountRole.READONLY_SIGNER
            : a.isWritable
              ? AccountRole.WRITABLE
              : AccountRole.READONLY,
    })),
    data: Uint8Array.from(getBase64Codec().encode(ix.data)),
  };
}

// 1. Request v1 instructions from /build
const res = await fetch(
  "https://api.jup.ag/swap/v2/build?" +
    new URLSearchParams({
      inputMint: "So11111111111111111111111111111111111111112",
      outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      amount: "100000000",
      taker: signer.address,
      slippageBps: "100",
      transactionVersion: "1",
    }),
  { headers: { "x-api-key": API_KEY } },
);
if (!res.ok) throw new Error(`/build failed: ${await res.text()}`);
const build = (await res.json()) as BuildResponse;
// For v1: build.computeBudgetInstructions is [] and
// build.addressesByLookupTableAddress is {}. The compute unit price is a field.

// 2. Collect the swap instructions (no compute-budget instructions, no ALTs)
const instructions = [
  ...build.setupInstructions.map(toInstruction),
  toInstruction(build.swapInstruction),
  ...(build.cleanupInstruction ? [toInstruction(build.cleanupInstruction)] : []),
  ...build.otherInstructions.map(toInstruction),
  ...(build.tipInstruction ? [toInstruction(build.tipInstruction)] : []),
];

const blockhash = {
  blockhash: getBase58Decoder().decode(
    Uint8Array.from(build.blockhashWithMetadata.blockhash),
  ) as Blockhash,
  lastValidBlockHeight: BigInt(build.blockhashWithMetadata.lastValidBlockHeight),
};

// Build a v1 message at a given compute unit limit. priorityFeeLamports is an
// absolute lamport total (a bigint): compute unit price x limit, rounded up.
function buildV1Message(computeUnitLimit: number) {
  const priorityFeeLamports = BigInt(
    Math.ceil((Number(build.computeUnitPrice) * computeUnitLimit) / 1_000_000),
  );
  return pipe(
    createTransactionMessage({ version: 1 }),
    (m) => setTransactionMessageFeePayerSigner(signer, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    (m) => appendTransactionMessageInstructions(instructions, m),
    (m) =>
      setTransactionMessageConfig(
        {
          computeUnitLimit,
          priorityFeeLamports,
          loadedAccountsDataSizeLimit: LOADED_ACCOUNTS_DATA_SIZE_LIMIT,
        },
        m,
      ),
  );
}

// 3. Simulate at the max limit to measure compute units used, then size with a 1.2x buffer
const simulation = await rpc
  .simulateTransaction(
    getBase64EncodedWireTransaction(compileTransaction(buildV1Message(COMPUTE_UNIT_LIMIT_MAX))),
    { encoding: "base64", commitment: "confirmed", replaceRecentBlockhash: true },
  )
  .send();
if (simulation.value.err) console.error("Simulation failed:", simulation.value.err);

const computeUnitLimit = simulation.value.unitsConsumed
  ? Math.min(Math.ceil(Number(simulation.value.unitsConsumed) * 1.2), COMPUTE_UNIT_LIMIT_MAX)
  : COMPUTE_UNIT_LIMIT_MAX;

// 4. Rebuild at the measured limit, sign, and send
const signed = await signTransactionMessageWithSigners(buildV1Message(computeUnitLimit));
const signature = await rpc
  .sendTransaction(getBase64EncodedWireTransaction(signed), {
    encoding: "base64",
    skipPreflight: true,
  })
  .send();
console.log("Submitted:", `https://solscan.io/tx/${signature}`);

// 5. Confirm the transaction landed, and surface an on-chain failure
for (let i = 0; i < 40; i++) {
  await new Promise((r) => setTimeout(r, 1500));
  const { value } = await rpc.getSignatureStatuses([signature]).send();
  const status = value[0];
  if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
    if (status.err) throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
    console.log("Confirmed:", signature);
    break;
  }
}