---
title: thru-base
description: Core Rust primitives for Thru, including key and address types,
  transaction builders, state proof helpers, and RPC config types.
source_url:
  html: https://thru.org/docs/sdks/rust-packages/thru-base/
  md: https://thru.org/docs/sdks/rust-packages/thru-base.md
---

# thru-base

Use `thru-base` when you need the shared Rust building blocks behind Thru accounts, transactions, address handling, and proof workflows.

## Install

```bash
cargo add thru-base
```

## When to use it

Choose this crate when you want to:

- Generate or load Thru keypairs and validate Thru-formatted addresses and signatures.
- Build raw Thru transactions in Rust, including transfers, account operations, token flows, uploader flows, and program-management instructions.
- Derive deterministic program, uploader, and manager account addresses.
- Encode, decode, or inspect state proofs and related proof metadata.
- Reuse shared request and filter types around Rust-side RPC tooling.

## Choose another crate when

- You want to call Thru gRPC services directly: use `thru-grpc-client`.
- You want a more ergonomic RPC client instead of raw primitives plus generated service types: use a higher-level wrapper such as `thru-client`.

## Entry points

| Module or export | What it provides |
| - | - |
| `thru_base::tn_tools::{KeyPair, Pubkey, Signature}` | Key generation, private-key loading, Thru address validation, and signature encoding helpers. |
| `thru_base::TransactionBuilder` and `thru_base::txn_tools` | Transaction builders plus program constants such as `EOA_PROGRAM`, `SYSTEM_PROGRAM`, `TOKEN_PROGRAM`, `UPLOADER_PROGRAM`, and more. |
| `thru_base::{StateProof, StateProofBody, StateProofHeader, StateProofType}` | Rust-side state proof creation, serialization, and parsing helpers. |
| `thru_base::{derive_manager_program_accounts, derive_uploader_program_accounts}` | Deterministic derived-account helpers for common program flows. |
| `thru_base::tn_public_address` exports | Encode and decode Thru addresses and create program-defined addresses. |
| `thru_base::rpc_types` | Shared Rust request-side types such as `GetProgramAccountsConfig`, `ProgramAccountFilter`, and `MakeStateProofConfig`. |

## Start here

This crate is most useful at the edges of a Rust integration: parse keys, build a transaction, sign it, then hand the bytes to a client layer.

```rust
use thru_base::tn_tools::{KeyPair, Pubkey};
use thru_base::txn_tools::EOA_PROGRAM;
use thru_base::TransactionBuilder;

fn build_transfer(
    from_private_key_hex: &str,
    to: &str,
    amount: u64,
    nonce: u64,
    start_slot: u64,
) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let from = KeyPair::from_hex_private_key("sender", from_private_key_hex)?;
    let to = Pubkey::new(to.to_string())?;

    let mut tx = TransactionBuilder::build_transfer(
        from.public_key,
        EOA_PROGRAM,
        to.to_bytes()?,
        amount,
        1,
        nonce,
        start_slot,
    )?;

    tx.sign(&from.private_key)?;
    Ok(tx.to_wire())
}
```

## Common workflows

| Task | Main entrypoints |
| - | - |
| Parse or validate account addresses | `Pubkey::new`, `Pubkey::from_hex`, `Pubkey::to_bytes`, `Pubkey::from_bytes` |
| Parse or format signatures | `Signature::new`, `Signature::to_bytes`, `Signature::from_bytes` |
| Create or load a signer | `KeyPair::generate`, `KeyPair::from_hex_private_key` |
| Build basic transactions | `TransactionBuilder::build_transfer`, `build_create_account`, `build_resize_account`, `build_write_data` |
| Build program-management flows | `build_manager_create`, `build_manager_upgrade`, `build_manager_set_pause`, `build_manager_set_authority` |
| Build token and wrapped-token flows | `build_token_initialize_mint`, `build_token_transfer`, `build_wthru_deposit`, `build_wthru_withdraw` |
| Work with proofs | `StateProof`, `StateProofHeader`, `StateProofBody`, `MakeStateProofConfig`, `ProofType` |
| Derive deterministic accounts | `derive_program_address`, `derive_manager_program_accounts`, `derive_uploader_program_accounts` |

## Notes for agents

- `Pubkey` and `Signature` are string-backed wrapper types for Thru-formatted `ta...` addresses and `ts...` signatures, not raw byte arrays.
- The builder methods usually expect raw `[u8; 32]` public keys for account arguments, so convert `Pubkey` wrappers with `to_bytes()` when needed.
- `thru-base` is broad: if your task is “call node RPC and read chain data,” this crate alone is probably not enough without a client layer.