# Where to Find the Core Source Code for Acton: Repository Structure and Key Modules

> Locate Acton's core source code in the ton-blockchain/acton repository's src/ folder. Discover the main entry point and key modules for CLI and library functions.

- Repository: [TON - The Open Network/acton](https://github.com/ton-blockchain/acton)
- Tags: internals
- Published: 2026-05-14

---

**The core source code for Acton is located entirely within the `src/` folder of the ton-blockchain/acton repository, with [`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs) serving as the main entry point that re-exports all primary modules for both CLI operations and library functionality.**

Acton is a Rust-based toolchain for TON blockchain development, maintained in the **ton-blockchain/acton** repository. Understanding the core source code layout is essential for developers contributing to the project or extending its capabilities through the public API exposed in [`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs).

## Core Directory Layout

All implementation logic resides under the `src/` directory at the repository root. This folder contains the **library root** ([`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs)) and **fifteen specialized modules** that handle everything from CLI parsing to blockchain interaction.

The [`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs) file serves as the public API surface, re-exporting every core module using explicit `pub mod` declarations:

```rust
// src/lib.rs
pub mod build_info;
pub mod commands;
pub mod context;
pub mod crash;
pub mod external_send;
pub mod ffi;
pub mod file_build_cache;
pub mod formatter;
pub mod http;
pub mod paths;
pub mod retrace;
pub mod stdlib;
pub mod tonconnect;
pub mod wallets;

```

## Module Architecture

The core source code is organized into logical units that separate concerns between blockchain interaction, development tooling, and runtime support.

### Entry Point and Public API

The **[`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs)** file defines the crate's public interface. It aggregates functionality from all sub-modules, making them available to both the Acton CLI binary and external Rust consumers importing the library.

### CLI Commands Implementation

The **`src/commands/`** directory contains the implementation for every CLI sub-command, including `acton build`, `acton test`, `acton wallet`, and `acton script`. Each command maps to a specific module within this directory, handling argument parsing and orchestrating calls to underlying library functions.

### Wallet Management

**[`src/wallets.rs`](https://github.com/ton-blockchain/acton/blob/main/src/wallets.rs)** provides wallet creation, key generation, and signing utilities. This module supports multiple wallet versions (V5R1, etc.) and abstracts the complexity of TON address generation and cryptographic operations.

### Blockchain Integration

Two modules handle external communication:

- **[`src/external_send.rs`](https://github.com/ton-blockchain/acton/blob/main/src/external_send.rs)**: Utilities for sending external messages to the TON blockchain.
- **[`src/tonconnect.rs`](https://github.com/ton-blockchain/acton/blob/main/src/tonconnect.rs)**: Integration with the TON Connect protocol for wallet connectivity.

### Build System and Caching

**[`src/file_build_cache.rs`](https://github.com/ton-blockchain/acton/blob/main/src/file_build_cache.rs)** manages incremental build artifacts, storing cached compilation results and file hashes to optimize rebuild times. **[`src/context.rs`](https://github.com/ton-blockchain/acton/blob/main/src/context.rs)** provides the runtime **ProjectContext** that tracks project layout and configuration from [`acton.toml`](https://github.com/ton-blockchain/acton/blob/main/acton.toml).

### FFI and Runtime Bindings

The **`src/ffi/`** directory contains **Foreign Function Interface** wrappers that bridge Rust to the TON Virtual Machine. These low-level bindings enable execution of Tolk bytecode and support the test runner infrastructure.

### Supporting Infrastructure

Additional critical modules include:

- **[`src/formatter.rs`](https://github.com/ton-blockchain/acton/blob/main/src/formatter.rs)**: Pretty-printing of logs, traces, and execution reports.
- **[`src/http.rs`](https://github.com/ton-blockchain/acton/blob/main/src/http.rs)**: Minimal HTTP client for network interactions with TON Center and other endpoints.
- **[`src/paths.rs`](https://github.com/ton-blockchain/acton/blob/main/src/paths.rs)**: File-system path utilities for locating project files and configuration.
- **[`src/retrace.rs`](https://github.com/ton-blockchain/acton/blob/main/src/retrace.rs)**: Stack-trace reconstruction for contract execution failures.
- **[`src/crash.rs`](https://github.com/ton-blockchain/acton/blob/main/src/crash.rs)**: Error handling and back-trace reporting.
- **[`src/stdlib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/stdlib.rs)**: Built-in standard library definitions for Tolk scripts.
- **[`src/build_info.rs`](https://github.com/ton-blockchain/acton/blob/main/src/build_info.rs)**: Compile-time metadata including version and git hashes.

## Practical Code Examples

Developers can interact with Acton's core source code programmatically through the public API exposed in [`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs).

### Creating a Wallet Programmatically

Import the `wallets` module to generate and manage TON wallets:

```rust
use acton::wallets::{WalletBuilder, WalletKind};

fn main() -> anyhow::Result<()> {
    // Build a V5 wallet with a generated key pair
    let wallet = WalletBuilder::new()
        .kind(WalletKind::V5R1)   // select the version
        .local()                  // local (non-hardware) wallet
        .generate()?;             // generate keys

    println!("Address: {}", wallet.address);
    Ok(())
}

```

*Source*: [`src/wallets.rs`](https://github.com/ton-blockchain/acton/blob/main/src/wallets.rs)

### Executing Tolk Scripts

Access the commands module to run deployment scripts within the project context:

```rust
use acton::commands::script::run_script;
use acton::context::ProjectContext;

fn main() -> anyhow::Result<()> {
    let ctx = ProjectContext::load_from_cwd()?;          // locate acton.toml
    run_script(&ctx, "scripts/deploy.tolk", None)?;     // execute the script
    Ok(())
}

```

*Source*: [`src/commands/script/mod.rs`](https://github.com/ton-blockchain/acton/blob/main/src/commands/script/mod.rs)

### Accessing Build Cache

Interact with the incremental build system through the `file_build_cache` module:

```rust
use acton::file_build_cache::BuildCache;

fn main() -> anyhow::Result<()> {
    let cache = BuildCache::load()?;               // reads .acton/cache
    println!("Cached artifacts: {}", cache.entries().len());
    Ok(())
}

```

*Source*: [`src/file_build_cache.rs`](https://github.com/ton-blockchain/acton/blob/main/src/file_build_cache.rs)

## Summary

- **The core source code for Acton** is contained entirely within the `src/` directory of the ton-blockchain/acton repository.
- **[`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs)** serves as the central hub, re-exporting all fifteen core modules that power both CLI and library functionality.
- **Key modules** include `src/commands/` for CLI logic, [`src/wallets.rs`](https://github.com/ton-blockchain/acton/blob/main/src/wallets.rs) for cryptographic operations, and `src/ffi/` for VM bindings.
- **Practical integration** is available through Rust's module system, allowing direct use of `acton::wallets`, `acton::context`, and other public modules.
- **Build and deployment** logic resides in [`src/file_build_cache.rs`](https://github.com/ton-blockchain/acton/blob/main/src/file_build_cache.rs) and [`src/context.rs`](https://github.com/ton-blockchain/acton/blob/main/src/context.rs), managing project state and incremental compilation.

## Frequently Asked Questions

### Where is the main entry point for Acton's core library?

The main entry point is **[`src/lib.rs`](https://github.com/ton-blockchain/acton/blob/main/src/lib.rs)**, which re-exports all public modules including `wallets`, `commands`, `context`, and `ffi`. This file serves as the library root, exposing the complete API surface for both internal CLI usage and external Rust consumers who import the crate as a dependency.

### Which module handles CLI commands in Acton?

The **`src/commands/`** directory contains the implementation for all CLI sub-commands such as `acton build`, `acton test`, and `acton wallet`. Each sub-command maps to a specific file or subdirectory within `src/commands/`, handling argument parsing and orchestrating the underlying business logic.

### How does Acton manage wallet functionality?

Wallet operations are centralized in **[`src/wallets.rs`](https://github.com/ton-blockchain/acton/blob/main/src/wallets.rs)**, which provides the `WalletBuilder` API for creating local wallets, generating key pairs, and managing addresses. This module supports multiple wallet versions (such as V5R1) and abstracts TON-specific cryptographic operations for seamless integration with the broader toolchain.

### What module provides TON Connect integration?

The **[`src/tonconnect.rs`](https://github.com/ton-blockchain/acton/blob/main/src/tonconnect.rs)** file implements the TON Connect protocol integration, enabling Acton to interact with external wallet applications for transaction signing and user authentication. This module bridges the CLI tool with browser-based and mobile TON wallets following the TON Connect standard.