Build a Solana Devnet Toolkit with Kit

kit-toolkit/
  package.json
  tsconfig.json
  scripts/
    lib/
      solana.ts
    balance.ts
    inspect.ts
    send.ts

mkdir kit-toolkit
cd kit-toolkit
pnpm init
pnpm add @solana/kit @solana-program/system
pnpm add -D typescript tsx @types/node

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["scripts/**/*.ts"]
}

import { readFile } from "node:fs/promises";
import {
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
} from "@solana/kit";

export const DEVNET_RPC_URL = "https://api.devnet.solana.com";
export const DEVNET_WS_URL = "wss://api.devnet.solana.com";

// One HTTP RPC client for read requests and transaction-building data.
export const rpc = createSolanaRpc(DEVNET_RPC_URL);

// One subscriptions client for waiting on transaction confirmation.
export const rpcSubscriptions = createSolanaRpcSubscriptions(DEVNET_WS_URL);

export async function loadSignerFromFile(path: string) {
  // Solana CLI keypair files are JSON arrays of secret key bytes.
  const file = await readFile(path, "utf8");
  const bytes = new Uint8Array(JSON.parse(file));

  // Convert raw bytes into a Kit signer that can actually sign transactions.
  return createKeyPairSignerFromBytes(bytes);
}

import { address } from "@solana/kit";
import { rpc } from "./lib/solana";

async function main() {
  const input = process.argv[2];

  if (!input) {
    throw new Error("Usage: pnpm tsx scripts/balance.ts <ADDRESS>");
  }

  // Convert the raw string into a typed Solana address.
  const accountAddress = address(input);
  const { value: balanceInLamports } = await rpc.getBalance(accountAddress).send();

  console.log({
    address: input,
    lamports: balanceInLamports.toString(),
    sol: Number(balanceInLamports) / 1_000_000_000,
  });
}

main().catch((error) => {
  console.error("balance failed", error);
  process.exit(1);
});

pnpm tsx scripts/balance.ts $(solana address -k wallet1.json)

import { address, fetchEncodedAccount } from "@solana/kit";
import { rpc } from "./lib/solana";

async function main() {
  const input = process.argv[2];

  if (!input) {
    throw new Error("Usage: pnpm tsx scripts/inspect.ts <ADDRESS>");
  }

  const accountAddress = address(input);
  const account = await fetchEncodedAccount(rpc, accountAddress);

  if (!account.exists) {
    console.log({ exists: false, address: input });
    return;
  }

  console.log({
    exists: true,
    address: input,
    lamports: account.lamports.toString(),
    owner: account.owner.toString(),
    executable: account.executable,
    dataLength: account.data.length,
  });
}

main().catch((error) => {
  console.error("inspect failed", error);
  process.exit(1);
});

pnpm tsx scripts/inspect.ts $(solana address -k wallet2.json)

import {
  address,
  appendTransactionMessageInstructions,
  createTransactionMessage,
  getSignatureFromTransaction,
  lamports,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import { loadSignerFromFile, rpc, rpcSubscriptions } from "./lib/solana";

async function main() {
  const senderKeypairPath = process.argv[2];
  const recipientAddressInput = process.argv[3];
  const amountSolInput = process.argv[4];

  if (!senderKeypairPath || !recipientAddressInput || !amountSolInput) {
    throw new Error(
      "Usage: pnpm tsx scripts/send.ts <SENDER_KEYPAIR_PATH> <RECIPIENT_ADDRESS> <AMOUNT_SOL>"
    );
  }

  const sender = await loadSignerFromFile(senderKeypairPath);
  const recipientAddress = address(recipientAddressInput);
  const amountSol = Number(amountSolInput);

  if (!Number.isFinite(amountSol) || amountSol <= 0) {
    throw new Error("Amount must be a positive SOL value like 0.01");
  }

  // Convert SOL into lamports so the on-chain amount is explicit.
  const amountLamports = BigInt(Math.round(amountSol * 1_000_000_000));

  // Fetch a fresh blockhash before building the transaction message.
  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

  // Build the transfer instruction for the System Program.
  const transferInstruction = getTransferSolInstruction({
    source: sender,
    destination: recipientAddress,
    amount: lamports(amountLamports),
  });

  // Build the transaction in the correct order:
  // message -> fee payer -> lifetime -> instructions.
  const message = pipe(
    createTransactionMessage({ version: 0 }),
    (tx) => setTransactionMessageFeePayerSigner(sender, tx),
    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
    (tx) => appendTransactionMessageInstructions([transferInstruction], tx)
  );

  // Sign after the message is fully built.
  const signedTransaction = await signTransactionMessageWithSigners(message);

  // Send the transaction bytes and wait for confirmation.
  const sendAndConfirm = sendAndConfirmTransactionFactory({
    rpc,
    rpcSubscriptions,
  });

  await sendAndConfirm(signedTransaction, { commitment: "confirmed" });

  console.log({
    signature: getSignatureFromTransaction(signedTransaction),
    from: sender.address,
    to: recipientAddress,
    amountSol,
  });
}

main().catch((error) => {
  console.error("send failed", error);
  process.exit(1);
});

pnpm tsx scripts/send.ts wallet1.json $(solana address -k wallet2.json) 0.01

pnpm tsx scripts/balance.ts $(solana address -k wallet1.json)
pnpm tsx scripts/balance.ts $(solana address -k wallet2.json)