# Blueprint: the TON contract toolchain, now in its final phase

> Blueprint was the all-in-one environment for writing, testing and deploying TON smart contracts in FunC, and it still is one, but the README opens with a deprecation notice: use Acton instead, pull requests are not accepted, and Tolk support has moved. Tact users are capped at version 0.46.0, and contract verification is gone.

**ton-org/blueprint** — TON development for professionals - all-in-one tool for writing, testing and deploying smart contracts

- Repository: https://github.com/ton-org/blueprint
- Website: https://www.npmjs.com/package/@ton/blueprint
- Stars: 651 · Forks: 178
- Language: TypeScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/ton-org-blueprint

## The first thing the README tells you is that it is over

Blueprint is deprecated. The README opens with a caution notice saying to use Acton instead, and that pull requests are not accepted at the moment, with problems and tasks to be brought to the issues tracker.

That framing changes what an evaluation of this project is for. This is no longer a framework to bet a greenfield project on. It is a tool that already has users, and the question for those users is how long they can keep running it and how expensive the eventual migration to Acton will be.

The notice is not a single line. There are three separate blocks at the top of the README. The first is the deprecation itself. The second says Tolk support has moved to Acton, and the third deals with Tact, which is separately deprecated by the Tact project, with the instruction that to continue using Tact you should use Blueprint 0.46.0 or earlier. A fourth warning states that Tact contract verification is no longer available, including in Blueprint 0.46.0 and earlier, and that you should not send testnet Gram to pay for Tact verification, because verification will fail and you may lose the testnet GRAM you send.

That last warning is the kind of detail that only appears when people have lost money to it. If you have a Tact project with verification in your workflow, that part of the pipeline has to be removed rather than migrated, and the funds you would have sent are not recoverable once sent.

## A FunC environment, and the pieces it is built from

Blueprint is an all-in-one development environment for creating, testing and deploying smart contracts on TON blockchain using the FunC language. The core features it lists are a development environment created from a template with npm create ton@latest, a single workflow for building, testing and deploying, deployment to mainnet or testnet using a wallet such as Tonkeeper, and fast testing of multiple smart contracts in an isolated blockchain running in-process.

The tech stack section names the three components it delegates to. FunC compilation is handled by func-js from the ton-community organisation. Contract testing is handled by the Sandbox project, ton-org/sandbox. Deployment goes through TON Connect 2 or a ton:// deeplink.

The requirements are modest. Node.js with a recent version such as v18, verified with node -v, and an IDE with TON support, either Visual Studio Code with the TON plugin or IntelliJ IDEA with the TON Development plugin, which covers Tolk, FunC and Fift.

The package metadata confirms the shape of the tool. The npm package is @ton/blueprint at version 0.47.1, with a binary at dist/cli/cli.js, and the peer dependencies are @ton/core, @ton/crypto, @ton/ton and @ton-community/func-js, with @ton/sandbox marked optional. Runtime dependencies include @tonconnect/sdk for wallet connections, @ton-api/client and @ton-api/ton-adapter, arg for command line parsing and axios. The toolchain itself is a separate package, @ton/toolchain, which also provides the shared prettier configuration.

## The project template that npm create ton produces

Getting started is one command in the terminal, followed by the on-screen instructions:

```console
npm create ton@latest
```

The same generator is reachable as npx create-ton@latest, and after the project directory is created you run npm or yarn install to pull in the dependencies.

The directory structure the template produces is worth understanding before you write anything, because each directory has a distinct job. contracts/ holds the source code for all smart contracts and their imports. wrappers/ holds TypeScript interface classes for the contracts, each implementing the Contract interface from @ton/core, including message serialization and deserialization primitives, getter wrappers and compilation functions, and these wrappers are what the test suite and your client code use to talk to the contracts from TypeScript. compilables/ holds the compilation scripts. tests/ is the TypeScript test suite, relying on Sandbox for the in-process tests. scripts/ holds deployment scripts for mainnet and testnet plus other scripts that interact with live contracts. build/ is where compilation artefacts land after a build.

The split between contracts and wrappers is the interesting architectural decision. The contract logic is FunC, and everything on the TypeScript side is generated or hand written against a typed interface to it, so a change to a message format is a change in the wrapper rather than a change in the test code that calls it.

## Building and testing through the blueprint CLI

The CLI is available through npx or yarn, and the same commands are exposed as npm scripts.

To build, you need a compilation script at compilables/<CONTRACT>.compile.ts. Then run npx blueprint build or yarn blueprint build for the interactive form, npx blueprint build <CONTRACT> or yarn blueprint build <CONTRACT> for a single contract non-interactively, and yarn blueprint build --all to build every contract. The README's own example is yarn blueprint build counter. Results are written to build/<CONTRACT>.compiled.json, and the Fift output sits at build/<CONTRACT>/<CONTRACT>.fif.

Testing follows the same shape. npx blueprint test or yarn blueprint test runs the suite, npm test or yarn test is the alternative, and you can point at a single contract with npm or yarn test <CONTRACT>, for example yarn test counter. The tests are TypeScript and run against the in-process sandbox blockchain, which is what makes the fast testing claim in the feature list plausible: there is no node to start and no network to wait for.

Scripts are the third command. Custom scripts live in the scripts folder and the script file must export a function named run, with this signature:

```ts
export async function run(provider: NetworkProvider, args: string[]) {
  // 
}
```

The script is then executed with npx or yarn blueprint run <SCRIPT> [arg1, arg2, ...].

For deployment, the convention is a script named scripts/deploy<CONTRACT>.ts. Running npx blueprint run interactively walks you through the choices, and the non-interactive form passes the network and the deploy method as flags, for example yarn blueprint run deployCounter --mainnet --tonconnect.

## Wallet connections: TON Connect and the mnemonic provider

Deployment reaches a wallet in one of two ways. TON Connect 2 is the interactive path, and the alternative is a ton:// deeplink, which is how a script hands a request to a wallet such as Tonkeeper on the same device.

The other path is a mnemonic provider, which is the one that needs configuration and the one that deserves care. The README asks you to add environment variables to your .env file. WALLET_MNEMONIC holds the wallet's mnemonic phrase as space-separated words. WALLET_VERSION selects the wallet contract version, and the supported versions are listed as v1r1, v1r2, v1r3, v2r1, v2r2, v3r1, v3r2, v4r1, v4r2 or v4, and v5r1.

Three optional variables refine the wallet identity. WALLET_ID is the wallet ID, used with versions below v5r1. SUBWALLET_NUMBER is the subwallet number used to build the wallet ID with v5r1 wallets. WALLET_NETWORK_ID is the network ID used to build the wallet ID for v5 wallets, and it defaults to -3 for testnet and -239 for mainnet as well as for custom networks.

The defaults are worth internalising. A mnemonic in an environment file is a seed phrase on disk, and the network ID default of -3 for testnet is what keeps a testnet run from touching mainnet, but it is a default and not a guarantee, so the explicit flag in a non-interactive deployment is the safer habit. Once configured, you pick the Mnemonic option when running a script.

## What the framework still is, and where it stops

Even in its final phase, the value proposition is coherent. The three things it does, compile FunC, test in a sandbox, deploy through a wallet, are the three things every TON contract project does, and Blueprint wires them into one CLI and one project layout. A team that has a working Blueprint project today can keep shipping with it.

The alternative approaches differ in what they ask of you. Building the same pipeline by hand means wiring func-js, the Sandbox and TON Connect yourself and defining your own project layout, which is more work up front and more freedom afterwards, since nothing in the template is mandatory. Acton is the sanctioned successor, and the README's instruction to use it is the clearest signal about where TON tooling is going. The FunC language itself has its own documentation, and the sandbox has its own, so the components Blueprint composes remain available to a project that outgrows the wrapper.

The limits are equally clear. There is no Tolk support in the current versions, and there is no contract verification for Tact in any version. The plugin mechanism and the custom network configuration are mentioned in the table of contents but not covered in the documentation excerpt available here. And the project will not accept pull requests, so any bug you find in it is yours to work around or to carry into the migration.

The licence is MIT, recorded in the package metadata and in the LICENSE file, and the release record shows the usual rhythm of a package in maintenance, with 0.46.0 on 2026-09-18 and then 0.47.0 and 0.47.1 both on 2026-09-29, the last push on the same day.

## Conclusion

Blueprint suits an existing FunC project that already has its build, test and deployment scripts wired to it and needs to keep shipping without a migration, and it suits a new TON project poorly, since the README says to use Acton instead and no longer accepts pull requests. Before you start anything new, read the deprecation notice and the Tact constraints, because version 0.47.x has no Tolk support, Tact verification no longer works even in 0.46.0 and earlier, and the README warns that sending testnet Gram to pay for verification will fail and can cost you the funds. The package is MIT licensed, the last push was on 2026-09-29, and 0.47.1 was published the same day.

## FAQ

### Is Blueprint deprecated?

Yes. The README opens with a caution notice saying Blueprint is deprecated, that you should use Acton instead, and that pull requests are not accepted at the moment, with problems and tasks to be raised as issues.

### Which Blueprint version supports Tact?

The README says that to continue using Tact you should use Blueprint 0.46.0 or earlier, and that Tolk support has moved to Acton. It also warns that Tact contract verification is no longer available, even in 0.46.0 and earlier.

### How do I create a new Blueprint project?

Run npm create ton@latest in the terminal and follow the on-screen instructions, or use npx create-ton@latest. From the project directory, run npm or yarn install to install the dependencies.

### How do I build and test contracts with Blueprint?

Put a compilation script in compilables/<CONTRACT>.compile.ts, then run npx blueprint build, or yarn blueprint build <CONTRACT> for one contract and yarn blueprint build --all for every contract. Tests run with npx blueprint test, and a single contract with yarn test <CONTRACT>.

### What environment variables does the mnemonic provider need?

WALLET_MNEMONIC with the space-separated mnemonic phrase and WALLET_VERSION for the wallet contract version. The optional ones are WALLET_ID, SUBWALLET_NUMBER and WALLET_NETWORK_ID, which defaults to -3 for testnet and -239 for mainnet.

## Sources

- [License: MIT](https://github.com/ton-org/blueprint/blob/master/LICENSE)
- [Project website](https://www.npmjs.com/package/@ton/blueprint)
- [README](https://github.com/ton-org/blueprint/blob/master/README.md)
- [Releases](https://github.com/ton-org/blueprint/releases)
- [ton-org/blueprint on GitHub](https://github.com/ton-org/blueprint)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ton-org-blueprint