---
title: Account Management
description: Methods for managing accounts, balances, and rent in TypeScript
---

Methods for managing accounts, balances, and setting account state.

## airdrop

```typescript
airdrop(address: Address, lamports: Lamports): TransactionMetadata | FailedTransactionMetadata | null
```

Fund an account with lamports.

```typescript
import { lamports } from "@solana/kit";

// Airdrop 5 SOL
const result = client.svm.airdrop(account.address, lamports(5_000_000_000n));

if (result) {
  // Note: Result properties are getter functions
  console.log("Compute units:", result.computeUnitsConsumed());
}
```

## setAccount

```typescript
setAccount(account: EncodedAccount): LiteSVM
```

Directly set account state without a transaction.

```typescript
import { address, lamports } from "@solana/kit";

client.svm.setAccount({
  address: myAddress,
  data: new Uint8Array([1, 2, 3, 4]),
  executable: false,
  lamports: lamports(1_000_000n),
  programAddress: address("11111111111111111111111111111111"),
  space: 4n
});
```

### EncodedAccount Properties

| Property         | Type         | Description                   |
| ---------------- | ------------ | ----------------------------- |
| `address`        | `Address`    | Account public key            |
| `data`           | `Uint8Array` | Account data bytes            |
| `executable`     | `boolean`    | Whether account is executable |
| `lamports`       | `Lamports`   | SOL balance                   |
| `programAddress` | `Address`    | Owner program                 |
| `space`          | `bigint`     | Data size in bytes            |

## getAccount

```typescript
getAccount(address: Address): MaybeEncodedAccount
```

Retrieve account data.

```typescript
const account = client.svm.getAccount(myAddress);

if (account.exists) {
  console.log("Address:", account.address);
  console.log("Lamports:", account.lamports);
  console.log("Owner:", account.programAddress);
  console.log("Data:", account.data);
  console.log("Executable:", account.executable);
}
```

## getBalance

```typescript
getBalance(address: Address): Lamports | null
```

Get account SOL balance. Returns `null` if account doesn't exist.

```typescript
const balance = client.svm.getBalance(account.address);

if (balance !== null) {
  console.log("Balance:", balance, "lamports");
  console.log("Balance:", Number(balance) / 1e9, "SOL");
} else {
  console.log("Account does not exist");
}
```

## minimumBalanceForRentExemption

```typescript
minimumBalanceForRentExemption(dataLen: bigint): bigint
```

Calculate the minimum lamports needed for rent exemption.

```typescript
const dataSize = 100n;
const minBalance = client.svm.minimumBalanceForRentExemption(dataSize);

console.log(
  `Rent-exempt minimum for ${dataSize} bytes:`,
  minBalance,
  "lamports"
);

// Use when setting up accounts
client.svm.setAccount({
  address: myAddress,
  data: new Uint8Array(Number(dataSize)),
  executable: false,
  lamports: lamports(minBalance),
  programAddress: programId,
  space: dataSize
});
```

## Program Management

### addProgram

```typescript
addProgram(programId: Address, programBytes: Uint8Array): LiteSVM
```

Load a program from bytes.

```typescript
const programBytes = fs.readFileSync("path/to/program.so");
client.svm.addProgram(programId, programBytes);
```

### addProgramFromFile

```typescript
addProgramFromFile(programId: Address, path: string): LiteSVM
```

Load a program from a `.so` file path.

```typescript
import { generateKeyPairSigner } from "@solana/kit";

const programId = await generateKeyPairSigner().then((s) => s.address);
client.svm.addProgramFromFile(
  programId,
  "/path/to/target/deploy/my_program.so"
);
```

## Batch Account Setup

For testing, you can set up multiple accounts efficiently:

```typescript
// Set up multiple test accounts
const accounts = await Promise.all(
  Array.from({ length: 10 }, () => generateKeyPairSigner())
);

for (const [index, account] of accounts.entries()) {
  client.svm.setAccount({
    address: account.address,
    data: new Uint8Array([index]),
    executable: false,
    lamports: lamports(1_000_000n),
    programAddress: address("11111111111111111111111111111111"),
    space: 1n
  });
}
```

<Callout type="info">
  Using `setAccount` is faster than `airdrop` for bulk account setup since it
  doesn't execute transactions.
</Callout>