Building and sending transactions in TypeScript

import { Connection, PublicKey, SystemProgram, LAMPORTS_PER_SOL } from "@solana/web3.js";
import {
  createAssociatedTokenAccountIdempotentInstruction,
  createTransferCheckedInstruction,
  getAssociatedTokenAddressSync,
} from "@solana/spl-token";

const connection = new Connection("https://api.devnet.solana.com", "confirmed");

// 0.01 SOL to a friend
const paySol = SystemProgram.transfer({
  fromPubkey: me,
  toPubkey: friend,
  lamports: 0.01 * LAMPORTS_PER_SOL,
});

// 5 tokens of a 6-decimal mint: create their ATA if missing, then transfer
const theirAta = getAssociatedTokenAddressSync(mint, friend);
const createAta = createAssociatedTokenAccountIdempotentInstruction(me, theirAta, friend, mint);
const sendTokens = createTransferCheckedInstruction(
  getAssociatedTokenAddressSync(mint, me), // source
  mint,
  theirAta,
  me,                                        // owner of the source
  5_000_000n,                                // amount in base units
  6                                          // decimals, checked on-chain
);

const instructions = [paySol, createAta, sendTokens];

import { ComputeBudgetProgram, TransactionMessage, VersionedTransaction } from "@solana/web3.js";

async function simulate(connection, payer, instructions) {
  const { blockhash } = await connection.getLatestBlockhash("confirmed");
  const message = new TransactionMessage({ payerKey: payer, recentBlockhash: blockhash, instructions })
    .compileToV0Message();
  const tx = new VersionedTransaction(message);

  const { value } = await connection.simulateTransaction(tx, {
    sigVerify: false,             // no signatures yet
    replaceRecentBlockhash: true, // don't fail on a stale one
    commitment: "confirmed",
  });
  return { ok: !value.err, err: value.err, logs: value.logs ?? [], units: value.unitsConsumed ?? null };
}

const sim = await simulate(connection, me, instructions);
if (!sim.ok) throw new Error(`would fail: ${JSON.stringify(sim.err)}\n${sim.logs.join("\n")}`);

const budgeted = [
  ComputeBudgetProgram.setComputeUnitLimit({ units: Math.ceil(sim.units * 1.1) }),
  ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1_000 }),
  ...instructions,
];

// In a browser the wallet signs. Never ask for a private key.
export async function sendInstructions(connection, wallet, instructions, signers = []) {
  if (!wallet?.publicKey) throw new Error("Wallet not connected");

  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("finalized");
  const tx = new Transaction({ feePayer: wallet.publicKey, blockhash, lastValidBlockHeight }).add(...instructions);

  // wallet-adapter: the wallet signs (and partially signs with any extra keypairs, e.g. a new mint)
  const signature = await wallet.sendTransaction(tx, connection, { signers, skipPreflight: false });

  const result = await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
  if (result.value?.err) throw new Error(`Transaction failed: ${JSON.stringify(result.value.err)} (${signature})`);
  return signature;
}

// On a server or in a script, a Keypair signs.
tx.sign(keypair);
const raw = tx.serialize();

async function sendAndConfirm(connection, raw: Uint8Array, lastValidBlockHeight: number) {
  const signature = await connection.sendRawTransaction(raw, { skipPreflight: true, maxRetries: 0 });

  while (true) {
    const { value } = await connection.getSignatureStatuses([signature]);
    const status = value[0];
    if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
      if (status.err) throw new Error(`failed on-chain: ${JSON.stringify(status.err)}`);
      return signature;
    }
    if ((await connection.getBlockHeight("confirmed")) > lastValidBlockHeight) {
      throw new Error("expired before it landed — rebuild with a fresh blockhash");
    }
    await connection.sendRawTransaction(raw, { skipPreflight: true, maxRetries: 0 }); // resend, same signature
    await new Promise((r) => setTimeout(r, 1_500));
  }
}

import { Keypair, NonceAccount, NONCE_ACCOUNT_LENGTH, SystemProgram, Transaction } from "@solana/web3.js";

// once: create the nonce account (you are its authority)
const nonceKp = Keypair.generate();
const rent = await connection.getMinimumBalanceForRentExemption(NONCE_ACCOUNT_LENGTH);
const create = new Transaction().add(
  SystemProgram.createNonceAccount({
    fromPubkey: me, noncePubkey: nonceKp.publicKey, authorizedPubkey: me, lamports: rent,
  })
);

// every time: read the current nonce and use it as the blockhash
const info = await connection.getAccountInfo(nonceKp.publicKey);
const nonce = NonceAccount.fromAccountData(info!.data).nonce;

const tx = new Transaction({ feePayer: me, nonceInfo: {
  nonce,
  nonceInstruction: SystemProgram.nonceAdvance({ noncePubkey: nonceKp.publicKey, authorizedPubkey: me }),
} }).add(...instructions);
// sign now, send whenever — it cannot expire, and it can land only once, because sending advances the nonce