Acton TON Developer Tooling: Complete CLI Toolkit for Smart Contract Development

Acton provides an all-in-one Rust-based command-line toolkit that covers the entire TON smart contract lifecycle—from project scaffolding and compilation to testing, deployment, and verification.

Acton is a unified development environment for the TON blockchain ecosystem, distributed as a single binary that bundles every stage of smart contract development. Unlike fragmented toolchains requiring separate installers for compilers, testers, and deployment scripts, Acton consolidates these capabilities into one consistent interface. Whether you are writing contracts in Tolk or managing complex deployment workflows, Acton TON developer tooling delivers the speed and reliability of native Rust implementation across macOS, Linux, and Windows (via WSL).

Project Scaffolding and Initialization

Acton eliminates setup friction with automated project generation. The acton new command, implemented in src/commands/new/mod.rs, creates ready-to-code repositories complete with boilerplate contracts, TypeScript wrappers, and preconfigured local testnet settings.

Developers can initialize existing directories using acton init (found in src/commands/init/mod.rs), while acton meta handles project metadata operations. Templates are available for common contract patterns, ensuring consistent structure across teams.

Build System and Compilation

The build pipeline converts .tolk source files into TVM bytecode through acton build, defined in src/commands/build/mod.rs. This command leverages a native Rust-based build graph for incremental compilation, significantly reducing rebuild times during iterative development.

The build system automatically manages dependencies and outputs both .tvc (contract code) and .abi (Application Binary Interface) files required for deployment.

Testing Framework

Acton delivers enterprise-grade testing capabilities through acton test in src/commands/test/mod.rs. The framework supports:

• Unit tests with built-in assertion libraries
• Fork mode for testing against live network states
• Gas snapshot comparison to detect unexpected cost changes
• Coverage analysis identifying untested code paths
• Mutation testing verifying test suite robustness
• Fuzzing for input validation

Failed tests trigger rich trace output via src/commands/test/trace.rs, displaying execution logs and VM state in an interactive UI. Run acton test --trace to enable step-by-step debugging for complex failures.

Deployment and Scripting

The toolkit streamlines blockchain interactions through two primary commands. acton script, located in src/commands/script/mod.rs, executes arbitrary .tolk scripts against any network:

acton script scripts/deploy.tolk --net testnet
acton script scripts/mint.tolk --net mainnet

For wallet operations, src/commands/wallet/mod.rs implements acton wallet new, which generates local testnet wallets with automatic airdrop funding. The acton up command runs predefined deployment workflows, enabling CI/CD integration for complex migration sequences.

Verification, Linting, and Formatting

Code quality tools ensure production-ready contracts. src/commands/verify/mod.rs provides acton verify for comparing local builds against on-chain bytecode, preventing deployment of unverified sources.

Static analysis runs via acton check (src/commands/check/mod.rs), detecting common vulnerabilities and anti-patterns. The formatter (src/commands/fmt/mod.rs) enforces consistent style across both Tolk contracts and Rust tooling code through acton fmt.

Low-Level VM Tooling

For advanced debugging and reverse engineering, src/commands/disasm/mod.rs exposes acton disasm, a TVM disassembler capable of deconstructing on-chain contracts. This enables security researchers and developers to inspect remote execution and verify third-party contract behavior without source access.

Documentation Generation

Acton automates API documentation through acton docgen in src/commands/docgen/mod.rs. This command generates TypeScript type definitions and contract interfaces from source code, accelerating dApp development by ensuring frontend types always match contract signatures.

acton docgen stdlib
acton docgen <contract-name>

Complete Development Workflow

The following 10-step workflow demonstrates a typical Acton development cycle:

# 1️⃣ Scaffold a new counter contract

acton new my_counter --template counter

cd my_counter

# 2️⃣ Build the contract (produces .tvc and .abi files)

acton build

# 3️⃣ Run the full test suite locally

acton test

# 4️⃣ Create a local test-net wallet and fund it

acton wallet new --name deployer --local --airdrop --version v5r1

# 5️⃣ Deploy the contract to testnet with a Tolk script

acton script scripts/deploy.tolk --net testnet

# 6️⃣ Verify the deployed contract matches the local build

acton verify --net testnet

# 7️⃣ Lint & format the source code

acton check
acton fmt

# 8️⃣ Generate TypeScript wrappers for dApp development

acton docgen stdlib

# 9️⃣ Run a custom script (e.g., token minting)

acton script scripts/mint.tolk --net testnet

# 10️⃣ Use the built-in debugger for a failing test

acton test --trace

All commands include comprehensive help documentation accessible via acton help <command>.

Summary

Acton TON developer tooling consolidates the entire smart contract lifecycle into a single Rust binary:

• Scaffolding: Template-based project generation via src/commands/new/mod.rs and initialization via src/commands/init/mod.rs
• Building: Native Rust build pipeline in src/commands/build/mod.rs for fast Tolk compilation
• Testing: Comprehensive framework in src/commands/test/mod.rs including fork mode, gas snapshots, coverage, mutation testing, and trace debugging
• Deployment: Script execution (src/commands/script/mod.rs) and wallet management (src/commands/wallet/mod.rs) with multi-network support
• Quality: Verification (src/commands/verify/mod.rs), linting (src/commands/check/mod.rs), and formatting (src/commands/fmt/mod.rs)
• Documentation: Automatic TypeScript wrapper generation via src/commands/docgen/mod.rs

Frequently Asked Questions

What programming languages does Acton support?

Acton primarily supports Tolk for smart contract development and TypeScript for wrapper generation and frontend integration. The toolkit itself is written in Rust, and acton fmt can format both Tolk and Rust source files according to standardized style guides.

How does Acton testing differ from other TON testing frameworks?

Unlike basic testing tools, Acton provides fork mode for testing against live network states without simulation, gas snapshot comparison to detect regression in computational costs, and mutation testing to validate test suite thoroughness. The interactive trace viewer in src/commands/test/trace.rs provides VM-level execution visibility unavailable in standard frameworks.

Can Acton deploy contracts to TON mainnet?

Yes. While Acton defaults to safe local testing environments, the acton script command accepts a --net mainnet flag for production deployments. The acton verify command (implemented in src/commands/verify/mod.rs) ensures deployed bytecode matches local compilation outputs, preventing accidental deployment of outdated or unverified contract versions.

Is Acton suitable for developers new to TON blockchain?

Acton lowers the barrier to entry through acton new --template <name>, which generates fully configured starter projects including local testnet setup. The unified CLI eliminates the complexity of installing and configuring separate compilers, testers, and deployment tools, allowing beginners to focus on contract logic rather than toolchain management.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}