SOL, Lamports & Units

Solana stores all native currency as lamports - unsigned 64-bit integers. Understanding denominations prevents rounding bugs, failed transactions, and incorrect fee calculations.

Recipe

Quick-reference recipe card - copy-paste ready.

import { lamports } from "@solana/kit";
 
const ONE_SOL = 1_000_000_000n;
const halfSol = lamports(500_000_000n);
 
function solToLamports(sol: number): bigint {
  return BigInt(Math.round(sol * 1e9));
}
 
function lamportsToSol(lps: bigint): string {
  return (Number(lps) / 1e9).toFixed(9);
}

When to reach for this:

• Converting user-facing SOL amounts to on-chain lamports before building instructions
• Displaying balances fetched from RPC without precision loss
• Calculating rent-exempt minimum deposits for new accounts
• Comparing priority fees (microlamports per CU) against base fees (lamports per signature)
• Validating SPL token amounts against mint decimals (separate from native SOL)

Working Example

import { createSolanaRpc, address, lamports } from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  pipe,
} from "@solana/kit";
 
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const sender = address("SENDER_PUBKEY");
const recipient = address("RECIPIENT_PUBKEY");
 
// User enters "0.25" SOL in a UI form
const userInputSol = 0.25;
const amountLamports = BigInt(Math.round(userInputSol * 1_000_000_000));
 
const { value: balance } = await rpc.getBalance(sender).send();
if (balance < amountLamports) {
  throw new Error(
    `Insufficient: have ${Number(lamports(balance)) / 1e9} SOL, need ${userInputSol}`,
  );
}
 
const { value: blockhash } = await rpc.getLatestBlockhash().send();
const transferIx = getTransferSolInstruction({
  source: sender,
  destination: recipient,
  amount: amountLamports,
});
 
const message = pipe(
  createTransactionMessage({ version: 0 }),
  (m) => setTransactionMessageFeePayer(sender, m),
  (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
  (m) => appendTransactionMessageInstruction(transferIx, m),
);
 
console.log("Transfer message built for", amountLamports, "lamports");

What this demonstrates:

• User input is converted to bigint lamports before any on-chain comparison
• getBalance returns lamports - compare integers, not floats
• Kit's lamports() helper wraps raw values for type clarity
• Transaction amounts are always whole lamport integers

Deep Dive

How It Works

• The genesis and all runtime accounting use lamports as the atomic unit
• 1 SOL = 10^9 lamports - the same relationship as wei to ETH, but with 9 decimals
• Account balances, transfers, rent, and fees are all u64 lamport values
• Floating-point types cannot represent all lamport values exactly at scale

Denominations at a Glance

Rust Notes

use anchor_lang::prelude::*;
 
const LAMPORTS_PER_SOL: u64 = 1_000_000_000;
 
pub fn transfer_amount(ctx: Context<Transfer>, sol: f64) -> Result<()> {
    let lamports = (sol * LAMPORTS_PER_SOL as f64) as u64; // avoid in production
    // Prefer: user supplies lamports directly, or use a fixed-point crate
    require!(lamports > 0, ErrorCode::ZeroAmount);
    Ok(())
}

• Never cast f64 to u64 in production financial code - use integer input
• anchor_lang provides Lamports type alias in some contexts
• Use checked_add, checked_sub for balance arithmetic in programs

Gotchas

• JavaScript float rounding - 0.1 + 0.2 !== 0.3 can produce wrong lamport amounts. Fix: parse user strings to bigint via integer math or a decimal library.
• Displaying u64 in JS - values above Number.MAX_SAFE_INTEGER lose precision. Fix: format lamports as bigint or use a string-based formatter.
• Mixing SOL and lamports in APIs - some CLI flags use SOL, RPC returns lamports. Fix: read each API's docs and normalize at your app boundary.
• SPL token decimals differ - USDC uses 6 decimals, SOL uses 9. Fix: always read mint.decimals before converting token amounts.
• Rent calculation in SOL - developers sometimes round rent to 0. Fix: use getMinimumBalanceForRentExemption RPC and store the exact lamport value.
• Priority fee units - microlamports per CU is not the same as lamports per signature. Fix: set both via Compute Budget instructions separately.

Alternatives

FAQs

function parseSolToLamports(input: string): bigint {
  const [whole, frac = ""] = input.split(".");
  const padded = (frac + "000000000").slice(0, 9);
  return BigInt(whole) * 1_000_000_000n + BigInt(padded);
}

Related

• Solana Basics - orientation to accounts and transactions
• Keypairs & Addresses - who holds the lamports
• Clusters & Networks - devnet airdrop amounts

Stack versions: This page was written for Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0, and LiteSVM 0.6.x.