@ton/blueprint 0.29.0 → 0.31.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.31.0] - 2025-04-24
+
+### Added
+
+- Added Fift output for FunC and Tolk build command
+- Added API reference in code
+
+### Changed
+
+- Improved CLI appearance
+
+## [0.30.0] - 2025-04-08
+
+### Fixed
+
+- Fixed Tact compilation
+
+### Changed
+
+- Updated Tact templates and `@tact-lang/compiler` dependency to v1.6.5
+
 ## [0.29.0] - 2025-03-02
 
 ### Changed
@@ -199,18 +220,18 @@ This release contains a breaking change.
 
 ### Fixed
 
-- Fixed TACT imports
+- Fixed Tact imports
 - Fixed missing newlines when printing error messages while building contracts
 
 ## [0.11.0] - 2023-07-03
 
 ### Added
 
-- Added an `options` field to the `tact` variant of `CompilerConfig`, which is of the same type as the `options` of the TACT compiler, and includes fields such as `debug`, `experimental`, etc
+- Added an `options` field to the `tact` variant of `CompilerConfig`, which is of the same type as the `options` of the Tact compiler, and includes fields such as `debug`, `experimental`, etc
 
 ### Changed
 
-- Updated TACT to 1.1.3
+- Updated Tact to 1.1.3
 
 ## [0.10.0] - 2023-06-06
 
@@ -226,7 +247,7 @@ This release contains a breaking change.
 
 ### Changed
 
-- Updated dependencies, of note: func-js to use func 0.4.3, TACT to 1.1.1
+- Updated dependencies, of note: func-js to use func 0.4.3, Tact to 1.1.1
 
 ## [0.8.0] - 2023-04-07
 
@@ -255,7 +276,7 @@ This release contains a breaking change.
 
 ### Added
 
-- Added support for [TACT](https://github.com/tact-lang/tact), including TACT smart contract templates
+- Added support for [Tact](https://github.com/tact-lang/tact), including Tact smart contract templates
 - Added `--all` option for `build` command
 
 ### Changed

package/README.md

@@ -60,7 +60,7 @@ Blueprint is an all-in-one development environment designed to enhance the proce
 
 * [Node.js](https://nodejs.org) with a recent version like v18. Version can be verified with `node -v`
 * IDE with TON support:
-  * [Visual Studio Code](https://code.visualstudio.com/) with the [FunC plugin](https://marketplace.visualstudio.com/items?itemName=tonwhales.func-vscode) or [Tolk plugin](https://marketplace.visualstudio.com/items?itemName=ton-core.tolk-vscode)
+  * [Visual Studio Code](https://code.visualstudio.com/) with the [FunC plugin](https://marketplace.visualstudio.com/items?itemName=tonwhales.func-vscode), [Tolk plugin](https://marketplace.visualstudio.com/items?itemName=ton-core.tolk-vscode) or [Tact plugin](https://marketplace.visualstudio.com/items?itemName=tonstudio.vscode-tact)
   * [IntelliJ IDEA](https://www.jetbrains.com/idea/) with the [TON Development plugin](https://plugins.jetbrains.com/plugin/23382-ton)
 
 ## Features overview
@@ -89,6 +89,7 @@ Blueprint is an all-in-one development environment designed to enhance the proce
    * Example: `yarn blueprint build counter`
 4. Build results are generated in `build/<CONTRACT>.compiled.json`
 5. Tact generated files are located in `build/<CONTRACT>` directory
+6. Fift output is located in `build/<CONTRACT>/<CONTRACT>.fif`
 
 ### Running the test suites
 

package/dist/build.js

@@ -46,6 +46,11 @@ async function buildOne(contract, ui) {
         ui?.write(JSON.stringify(res, null, 2));
         await promises_1.default.mkdir(paths_1.BUILD_DIR, { recursive: true });
         await promises_1.default.writeFile(buildArtifactPath, JSON.stringify(res));
+        if (result.lang === 'func' || result.lang === 'tolk') {
+            const fiftFilepath = path_1.default.join(paths_1.BUILD_DIR, contract, `${contract}.fif`);
+            await promises_1.default.mkdir(path_1.default.join(paths_1.BUILD_DIR, contract));
+            await promises_1.default.writeFile(fiftFilepath, result.fiftCode);
+        }
         ui?.write(`\n✅ Wrote compilation artifact to ${path_1.default.relative(process.cwd(), buildArtifactPath)}`);
     }
     catch (e) {

package/dist/cli/cli.js

@@ -82,10 +82,14 @@ async function main() {
         ...effectiveRunners,
         ...runners,
     };
-    const runner = effectiveRunners[args._[0]];
+    const command = args._[0];
+    const runner = effectiveRunners[command];
     if (!runner) {
-        console.log(chalk_1.default.redBright(` Error: command not found.`) + ` Run 'blueprint help' to see available commands\n`);
+        console.log(chalk_1.default.redBright(`Error: command ${command} not found.`) + `\nRunning ${chalk_1.default.cyanBright('blueprint help')}...`);
+        const helpMessage = (0, help_1.buildHelpMessage)();
+        console.log(helpMessage);
         process.exit(1);
+        return;
     }
     const ui = new InquirerUIProvider_1.InquirerUIProvider();
     await runner(args, ui, runnerContext);

package/dist/cli/constants.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.helpMessages = exports.helpArgs = exports.templateTypes = void 0;
+const chalk_1 = __importDefault(require("chalk"));
 exports.templateTypes = [
     {
         name: 'An empty contract (FunC)',
@@ -11,7 +15,7 @@ exports.templateTypes = [
         value: 'tolk-empty',
     },
     {
-        name: 'An empty contract (TACT)',
+        name: 'An empty contract (Tact)',
         value: 'tact-empty',
     },
     {
@@ -23,75 +27,71 @@ exports.templateTypes = [
         value: 'tolk-counter',
     },
     {
-        name: 'A simple counter contract (TACT)',
+        name: 'A simple counter contract (Tact)',
         value: 'tact-counter',
     },
 ];
 exports.helpArgs = { '--help': Boolean };
+const availableCommands = ['create', 'run', 'build', 'set', 'help', 'test', 'verify', 'convert'];
 exports.helpMessages = {
-    help: `Usage: blueprint help [command]
+    help: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('help')} [${chalk_1.default.yellow('command')}]
 
 Displays this message if no command is specified, or displays detailed help for the specified command.
 
-Blueprint is generally invoked as follows: blueprint [command] [command-args] [flags]
+Blueprint is generally invoked as follows:
+  ${chalk_1.default.cyan('blueprint')} ${chalk_1.default.yellow('[command]')} ${chalk_1.default.gray('[command-args]')} ${chalk_1.default.gray('[flags]')}
 
-List of available commands:
-- create
-- run
-- build
-- set
-- help
-- test
-- verify
-- convert`,
-    create: `Usage: blueprint create [contract name] [flags]
+${chalk_1.default.bold('List of available commands:')}
+${availableCommands.map(c => `- ${chalk_1.default.green(c)}`).join('\n')}`,
+    create: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('create')} ${chalk_1.default.yellow('[contract name]')} ${chalk_1.default.gray('[flags]')}
 
 Creates a new contract together with supporting files according to a template.
 
 Contract name must be specified in PascalCase and may only include characters a-z, A-Z, 0-9. If not specified on the command line, it will be asked interactively.
 
-Flags:
---type <type> - specifies the template type to use when creating the contract. If not specified on the command line, it will be asked interactively.
-List of available types:
-${exports.templateTypes.map((t) => `${t.value} - ${t.name}`).join('\n')}`,
-    run: `Usage: blueprint run [script name] [flags]
+${chalk_1.default.bold('Flags:')}
+${chalk_1.default.cyan('--type')} <type> - specifies the template type to use when creating the contract. If not specified on the command line, it will be asked interactively.
+
+${chalk_1.default.bold('List of available types:')}
+${exports.templateTypes.map((t) => `${chalk_1.default.cyan(t.value)} - ${t.name}`).join('\n')}`,
+    run: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('run')} ${chalk_1.default.yellow('[script name]')} ${chalk_1.default.gray('[flags]')}
 
 Runs a script from the scripts directory.
 
 Script name is matched (ignoring case) to a file in the scripts directory. If not specified on the command line, the available scripts will be presented interactively.
 
-Flags:
---mainnet, --testnet - specifies the network to use when running the script. If not specified on the command line, it will be asked interactively.
---custom [api-endpoint] - indicates that a custom API should be used when running the script, and the API URL optionally. (example: https://testnet.toncenter.com/api/v2/)
---custom-version - specifies the API version to use with the custom API. Options: v2 (default), v4.
---custom-key - specifies the API key to use with the custom API, can only be used with API v2.
---custom-type - specifies the network type to be indicated to scripts. Options: custom (default), mainnet, testnet.
---tonconnect, --deeplink, --mnemonic - specifies the deployer to use when running the script. If not specified on the command line, it will be asked interactively.
---tonscan, --tonviewer, --toncx, --dton - specifies the network explorer to use when displaying links to the deployed contracts. Default: tonviewer.`,
-    build: `Usage: blueprint build [contract name] [flags]
-
-Builds the specified contract according to the respective .compile.ts file. If the contract is written in TACT, all TACT-generated files (wrapper class, etc) will be placed in the build/<contract name> folder.
-
-If contract name is not specified on the command line, the buildable contracts (that have the respective .compile.ts files under wrappers directory) will be presented interactively, unless --all flag is specified.
-
-Flags:
---all - builds all buildable contracts instead of just one.`,
-    set: `Usage: blueprint set <key> [value]
-Available keys:
-- func - overrides @ton-community/func-js-bin version, effectively setting the func version. The required version may be passed as the value, otherwise available versions will be displayed.`,
-    test: `Usage: blueprint test [...args]
-
-Just runs \`npm test [...args]\`, which by default runs \`jest\`.`,
-    verify: `Usage: blueprint verify [contract name] [flags]
-
-Builds a contract (similar to build command) and verifies it on https://verifier.ton.org. The contract must be already deployed on the network. If the contract's name is not specified on the command line, it will be asked interactively.
-
-Flags:
---mainnet, --testnet - specifies the network to use when running the script. If not specified on the command line, it will be asked interactively.
---custom [api-endpoint] - indicates that a custom API should be used when running the script, and the API URL optionally. (example: https://testnet.toncenter.com/api/v2/) Requires --custom-type to be specified.
---custom-version - specifies the API version to use with the custom API. Options: v2 (defualt), v4.
---custom-key - specifies the API key to use with the custom API, can only be used with API v2.
---custom-type - specifies the network type to be indicated to scripts. Options: mainnet, testnet.`,
-    convert: `Usage: blueprint convert [path to build script]
-Atempts to convert legacy bash build script to a blueprint compile wrapper.`,
+${chalk_1.default.bold('Flags:')}
+${chalk_1.default.cyan('--mainnet')}, ${chalk_1.default.cyan('--testnet')} - selects network
+${chalk_1.default.cyan('--custom')} [api-endpoint] - use a custom API
+${chalk_1.default.cyan('--custom-version')} - API version (v2, v4)
+${chalk_1.default.cyan('--custom-key')} - API key (v2 only)
+${chalk_1.default.cyan('--custom-type')} - network type (custom, mainnet, testnet)
+${chalk_1.default.cyan('--tonconnect')}, ${chalk_1.default.cyan('--deeplink')}, ${chalk_1.default.cyan('--mnemonic')} - deployer options
+${chalk_1.default.cyan('--tonscan')}, ${chalk_1.default.cyan('--tonviewer')}, ${chalk_1.default.cyan('--toncx')}, ${chalk_1.default.cyan('--dton')} - explorer (default: tonviewer)`,
+    build: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('build')} ${chalk_1.default.yellow('[contract name]')} ${chalk_1.default.gray('[flags]')}
+
+Builds the specified contract according to the respective .compile.ts file. For Tact contracts, all generated files will be placed in the ${chalk_1.default.cyan('build/<contract name>')} folder.
+
+${chalk_1.default.bold('Flags:')}
+${chalk_1.default.cyan('--all')} - builds all available contracts.`,
+    set: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('set')} <${chalk_1.default.yellow('key')}> [${chalk_1.default.yellow('value')}]
+
+${chalk_1.default.bold('Available keys:')}
+- ${chalk_1.default.cyan('func')} - overrides @ton-community/func-js-bin version.`,
+    test: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('test')} [...args]
+
+Runs ${chalk_1.default.green('npm test [...args]')}, which by default executes ${chalk_1.default.green('jest')}.`,
+    verify: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('verify')} ${chalk_1.default.yellow('[contract name]')} ${chalk_1.default.gray('[flags]')}
+
+Verifies a deployed contract on ${chalk_1.default.underline('https://verifier.ton.org')}.
+
+${chalk_1.default.bold('Flags:')}
+${chalk_1.default.cyan('--mainnet')}, ${chalk_1.default.cyan('--testnet')} - selects network
+${chalk_1.default.cyan('--custom')} [api-endpoint] - use custom API (requires --custom-type)
+${chalk_1.default.cyan('--custom-version')} - API version (v2 default)
+${chalk_1.default.cyan('--custom-key')} - API key (v2 only)
+${chalk_1.default.cyan('--custom-type')} - network type (mainnet, testnet)`,
+    convert: `${chalk_1.default.bold('Usage:')} blueprint ${chalk_1.default.cyan('convert')} ${chalk_1.default.yellow('[path to build script]')}
+
+Attempts to convert a legacy bash build script to a Blueprint compile wrapper.`,
 };

package/dist/cli/help.d.ts

@@ -1,3 +1,4 @@
 import { Runner } from './Runner';
 export declare let additionalHelpMessages: Record<string, string>;
+export declare function buildHelpMessage(cmd?: string): string;
 export declare const help: Runner;

package/dist/cli/help.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.help = exports.additionalHelpMessages = void 0;
+exports.help = exports.buildHelpMessage = exports.additionalHelpMessages = void 0;
 const constants_1 = require("./constants");
 exports.additionalHelpMessages = {};
-const help = async (args, ui) => {
-    const cmd = args._.length >= 2 ? args._[1].toLowerCase() : '';
+function buildHelpMessage(cmd = '') {
     const effectiveHelpMessages = {
         ...exports.additionalHelpMessages,
         ...constants_1.helpMessages,
@@ -12,7 +11,12 @@ const help = async (args, ui) => {
     for (const k in exports.additionalHelpMessages) {
         effectiveHelpMessages.help += '\n- ' + k;
     }
-    const helpMessage = cmd in effectiveHelpMessages ? effectiveHelpMessages[cmd] : effectiveHelpMessages['help'];
+    return cmd in effectiveHelpMessages ? effectiveHelpMessages[cmd] : effectiveHelpMessages['help'];
+}
+exports.buildHelpMessage = buildHelpMessage;
+const help = async (args, ui) => {
+    const cmd = args._.length >= 2 ? args._[1].toLowerCase() : '';
+    const helpMessage = buildHelpMessage(cmd);
     ui.write(helpMessage);
 };
 exports.help = help;

package/dist/compile/CompilerConfig.d.ts

@@ -1,17 +1,42 @@
 import { SourceResolver, SourcesMap, SourcesArray } from '@ton-community/func-js';
 import { Cell } from '@ton/core';
-import { ConfigProject } from '@tact-lang/compiler';
+import { Options } from '@tact-lang/compiler';
 export type HookParams = {
     userData?: any;
 };
 export type CommonCompilerConfig = {
+    /**
+     * A hook that runs **before** the contract is compiled.
+     *
+     * @param {HookParams} params - Hook parameters including user-defined data.
+     *
+     * @example
+     * const config: CompilerConfig = {
+     *     preCompileHook: async (params) => {
+     *         console.log("Preparing to compile, user params:", params);
+     *     }
+     * };
+     */
     preCompileHook?: (params: HookParams) => Promise<void>;
+    /**
+     * A hook that runs **after** the contract is compiled.
+     *
+     * @param {Cell} code - The compiled contract code as a TON `Cell`.
+     * @param {HookParams} params - Hook parameters including user-defined data.
+     *
+     * @example
+     * const config: CompilerConfig = {
+     *     postCompileHook: async (code) => {
+     *         console.log("Compiled BOC size:", code.toBoc().length);
+     *     }
+     * };
+     */
     postCompileHook?: (code: Cell, params: HookParams) => Promise<void>;
 };
 export type TactCompilerConfig = {
     lang: 'tact';
     target: string;
-    options?: ConfigProject['options'];
+    options?: Options;
 };
 export type FuncCompilerConfig = {
     lang?: 'func';

package/dist/compile/compile.d.ts

@@ -10,12 +10,14 @@ export type SourceSnapshot = {
 export type TolkCompileResult = {
     lang: 'tolk';
     stderr: string;
+    fiftCode: string;
     code: Cell;
     snapshot: SourceSnapshot[];
     version: string;
 };
 export type FuncCompileResult = {
     lang: 'func';
+    fiftCode: string;
     code: Cell;
     targets: string[];
     snapshot: SourceSnapshot[];
@@ -29,7 +31,36 @@ export type TactCompileResult = {
 };
 export type CompileResult = TactCompileResult | FuncCompileResult | TolkCompileResult;
 export declare function doCompile(name: string, opts?: CompileOpts): Promise<CompileResult>;
+/**
+ * Optional compilation settings, including user data passed to hooks
+ */
 export type CompileOpts = {
+    /**
+     * Any user-defined data that will be passed to both `preCompileHook` and `postCompileHook`.
+     */
     hookUserData?: any;
 };
+/**
+ * Compiles a contract using the specified configuration for `tact`, `func`, or `tolk` languages.
+ *
+ * This function resolves the appropriate compiler configuration for a given contract name,
+ * runs any defined pre-compile and post-compile hooks, and returns the resulting compiled code
+ * as a [Cell]{@link Cell}.
+ *
+ * @param {string} name - The name of the contract to compile. This should correspond to a
+ *                        file named `<name>.compile.ts` in the `compilables` or `wrappers` directory.
+ * @param {CompileOpts} [opts] - Optional compilation options, including user data passed to hooks.
+ *
+ * @returns {Promise<Cell>} A promise that resolves to the compiled contract code as a `Cell`.
+ *
+ * @example
+ * import { compile } from '@ton/blueprint';
+ *
+ * async function main() {
+ *     const codeCell = await compile('Contract');
+ *     console.log('Compiled code BOC:', codeCell.toBoc().toString('base64'));
+ * }
+ *
+ * main();
+ */
 export declare function compile(name: string, opts?: CompileOpts): Promise<Cell>;

package/dist/compile/compile.js

@@ -62,6 +62,7 @@ async function doCompileTolk(config) {
     return {
         lang: 'tolk',
         stderr: res.stderr,
+        fiftCode: res.fiftCode,
         code: core_1.Cell.fromBase64(res.codeBoc64),
         snapshot: res.sourcesSnapshot.map((e) => ({
             filename: e.filename,
@@ -83,6 +84,7 @@ async function doCompileFunc(config) {
     }
     return {
         lang: 'func',
+        fiftCode: cr.fiftCode,
         code: core_1.Cell.fromBase64(cr.codeBoc),
         targets,
         snapshot: cr.snapshot,
@@ -124,11 +126,11 @@ async function doCompileTact(config, name) {
             output: path_1.default.join(paths_1.BUILD_DIR, name),
             options: { ...rootConfigOptions, ...config.options },
         },
-        stdlib: '/stdlib',
+        stdlib: Tact.createVirtualFileSystem("@stdlib", Tact.stdLibFiles),
         project: fs,
     };
     const res = await Tact.build(buildConfig);
-    if (!res) {
+    if (!res.ok) {
         throw new Error('Could not compile tact');
     }
     const code = findTactBoc(fs.overwrites);
@@ -174,6 +176,29 @@ async function doCompile(name, opts) {
     return res;
 }
 exports.doCompile = doCompile;
+/**
+ * Compiles a contract using the specified configuration for `tact`, `func`, or `tolk` languages.
+ *
+ * This function resolves the appropriate compiler configuration for a given contract name,
+ * runs any defined pre-compile and post-compile hooks, and returns the resulting compiled code
+ * as a [Cell]{@link Cell}.
+ *
+ * @param {string} name - The name of the contract to compile. This should correspond to a
+ *                        file named `<name>.compile.ts` in the `compilables` or `wrappers` directory.
+ * @param {CompileOpts} [opts] - Optional compilation options, including user data passed to hooks.
+ *
+ * @returns {Promise<Cell>} A promise that resolves to the compiled contract code as a `Cell`.
+ *
+ * @example
+ * import { compile } from '@ton/blueprint';
+ *
+ * async function main() {
+ *     const codeCell = await compile('Contract');
+ *     console.log('Compiled code BOC:', codeCell.toBoc().toString('base64'));
+ * }
+ *
+ * main();
+ */
 async function compile(name, opts) {
     const result = await doCompile(name, opts);
     return result.code;

package/dist/config/Config.d.ts

@@ -1,7 +1,40 @@
 import { CustomNetwork } from './CustomNetwork';
 import { Plugin } from './Plugin';
 export interface Config {
+    /**
+     * Optional array of plugins to extend or customize the behavior.
+     * Plugins can provide additional tooling.
+     *
+     * @example
+     * import { Config } from '@ton/blueprint';
+     * import { ScaffoldPlugin } from 'blueprint-scaffold';
+     *
+     * export const config: Config = {
+     *     plugins: [new ScaffoldPlugin()],
+     * };
+     */
     plugins?: Plugin[];
+    /**
+     * Specifies the target network for deployment or interaction.
+     *
+     * @example Custom network
+     * import { Config } from '@ton/blueprint';
+     *
+     * export const config: Config = {
+     *     network: {
+     *         endpoint: 'https://toncenter.com/api/v2/jsonRPC',
+     *         type: 'mainnet',
+     *         version: 'v2',
+     *         key: 'YOUR_API_KEY',
+     *     },
+     * };
+     */
     network?: 'mainnet' | 'testnet' | CustomNetwork;
+    /**
+     * If true, keeps compilable files (`*.compile.ts`) in a separate directory `compilables`.
+     * When false or unset, compilables are stored in `wrappers` directory.
+     *
+     * @default false
+     */
     separateCompilables?: boolean;
 }

package/dist/network/NetworkProvider.d.ts

@@ -3,15 +3,71 @@ import { Address, Cell, Contract, ContractProvider, OpenedContract, Sender } fro
 import { ContractAdapter } from '@ton-api/ton-adapter';
 import { UIProvider } from '../ui/UIProvider';
 export type BlueprintTonClient = TonClient4 | TonClient | ContractAdapter;
+/**
+ * Interface representing a network provider for interacting with TON blockchain.
+ */
 export interface NetworkProvider {
+    /**
+     * Returns the current network type.
+     * @returns {'mainnet' | 'testnet' | 'custom'} The type of network.
+     */
     network(): 'mainnet' | 'testnet' | 'custom';
+    /**
+     * Returns the sender used for transactions.
+     * @example
+     * export async function run(provider: NetworkProvider) {
+     *     await provider.sender().send({
+     *         to: randomAddress(),
+     *         value: toNano('0.5'),
+     *     })
+     * }
+     *
+     * @returns {Sender} The sender instance.
+     */
     sender(): Sender;
+    /**
+     * Returns the underlying TON client API. May be [TonClient4]{@link TonClient4}, [TonClient]{@link TonClient} or [ContractAdapter]{@link ContractAdapter} (TON API)
+     * @returns {BlueprintTonClient} The client API used to interact with the network.
+     */
     api(): BlueprintTonClient;
+    /**
+     * Returns a contract provider instance for a given address and optional init parameters.
+     * @param {Address} address - The address of the contract.
+     * @param {{ code?: Cell; data?: Cell }} [init] - Optional contact [StateInit]{@link StateInit}.
+     * @returns {ContractProvider} The contract provider - class to interact with contract
+     * @example
+     */
     provider(address: Address, init?: {
         code?: Cell;
         data?: Cell;
     }): ContractProvider;
+    /**
+     * Checks whether a contract is deployed.
+     * @param {Address} address - The address to check for deployment.
+     * @example
+     * export async function run(provider: NetworkProvider) {
+     *     const address = Address.parse('some address');
+     *     const isDeployed = await provider.isContractDeployed(address);
+     *     if (isDeployed) {
+     *         console.log('Contract deployed');
+     *     } else {
+     *         console.log('Contract not deployed');
+     *     }
+     * }
+     * @returns {Promise<boolean>} A promise that resolves to true if the contract is deployed, otherwise false.
+     */
     isContractDeployed(address: Address): Promise<boolean>;
+    /**
+     * Waits for a contract to be deployed by polling the address.
+     * @param {Address} address - The address to wait for deployment.
+     * @param {number} [attempts=20] - Maximum number of attempts to check for deployment.
+     * @param {number} [sleepDuration=2000] - Duration to wait between attempts, in milliseconds.
+     * @example
+     * await contract.sendDeploy(provider.sender(), toNano('0.05'));
+     * await provider.waitForDeploy(tolkTest.address);
+     * // run methods on `contract`
+     * @returns {Promise<void>} A promise that resolves when the contract is deployed or the attempts are exhausted.
+     */
     waitForDeploy(address: Address, attempts?: number, sleepDuration?: number): Promise<void>;
     /**
      * @deprecated
@@ -19,6 +75,22 @@ export interface NetworkProvider {
      * Use your Contract's `sendDeploy` method (or similar) together with `waitForDeploy` instead.
      */
     deploy(contract: Contract, value: bigint, body?: Cell, waitAttempts?: number): Promise<void>;
+    /**
+     * Opens a contract instance for interaction.
+     * @param {T} contract - The contract instance to open.
+     * @example
+     * const address = Address.parse('some address');
+     * const contract = provider.open(Contract.createFromAddress(address));
+     * await contract.send(provider.sender(), ...)
+     * @returns {OpenedContract<T>} An opened contract wrapper for interaction.
+     */
     open<T extends Contract>(contract: T): OpenedContract<T>;
+    /**
+     * Returns the UI provider used for writing data to graphical source (console).
+     * @returns {UIProvider} The UI provider instance.
+     * @example
+     * const ui = provider.ui();
+     * ui.write('Hello World!');
+     */
     ui(): UIProvider;
 }

package/dist/templates/tact/counter/contracts/contract.tact.template

@@ -1,25 +1,30 @@
 {{snakeName}}.tact
-import "@stdlib/deploy";
-
 message Add {
-    queryId: Int as uint64;
     amount: Int as uint32;
 }
 
-contract {{name}} with Deployable {
-    id: Int as uint32;
-    counter: Int as uint32;
-
-    init(id: Int) {
-        self.id = id;
-        self.counter = 0;
+contract {{name}}(
+    // Persistent state variables declared via the
+    // contract parameters syntax, which was introduced in v1.6.0
+    //
+    // See: https://docs.tact-lang.org/book/contracts/#parameters
+    id: Int as uint32,
+    counter: Int as uint32,
+) {
+    // Empty receiver for the deployment,
+    // which expects the `null` message body
+    receive() {
+        // Forward the remaining value in the
+        // incoming message back to the sender
+        cashback(sender());
     }
 
     receive(msg: Add) {
         self.counter += msg.amount;
 
-        // Notify the caller that the receiver was executed and forward remaining value back
-        self.notify("Cashback".asComment());
+        // Forward the remaining value in the
+        // incoming message back to the sender
+        cashback(sender());
     }
 
     get fun counter(): Int {

package/dist/templates/tact/counter/scripts/deploy.ts.template

@@ -4,17 +4,14 @@ import { {{name}} } from '../wrappers/{{name}}';
 import { NetworkProvider } from '@ton/blueprint';
 
 export async function run(provider: NetworkProvider) {
-    const {{loweredName}} = provider.open(await {{name}}.fromInit(BigInt(Math.floor(Math.random() * 10000))));
+    const {{loweredName}} = provider.open(await {{name}}.fromInit(BigInt(Math.floor(Math.random() * 10000))), 0n);
 
     await {{loweredName}}.send(
         provider.sender(),
         {
             value: toNano('0.05'),
         },
-        {
-            $$type: 'Deploy',
-            queryId: 0n,
-        }
+        null,
     );
 
     await provider.waitForDeploy({{loweredName}}.address);

package/dist/templates/tact/counter/scripts/increment.ts.template

@@ -24,7 +24,6 @@ export async function run(provider: NetworkProvider, args: string[]) {
         },
         {
             $$type: 'Add',
-            queryId: 0n,
             amount: 1n,
         }
     );

package/dist/templates/tact/counter/tests/spec.ts.template

@@ -12,7 +12,7 @@ describe('{{name}}', () => {
     beforeEach(async () => {
         blockchain = await Blockchain.create();
 
-        {{loweredName}} = blockchain.openContract(await {{name}}.fromInit(0n));
+        {{loweredName}} = blockchain.openContract(await {{name}}.fromInit(0n, 0n));
 
         deployer = await blockchain.treasury('deployer');
 
@@ -21,10 +21,7 @@ describe('{{name}}', () => {
             {
                 value: toNano('0.05'),
             },
-            {
-                $$type: 'Deploy',
-                queryId: 0n,
-            }
+            null,
         );
 
         expect(deployResult.transactions).toHaveTransaction({
@@ -62,7 +59,6 @@ describe('{{name}}', () => {
                 },
                 {
                     $$type: 'Add',
-                    queryId: 0n,
                     amount: increaseBy,
                 }
             );

package/dist/templates/tact/empty/contracts/contract.tact.template

@@ -1,9 +1,19 @@
 {{snakeName}}.tact
-import "@stdlib/deploy";
-
-contract {{name}} with Deployable {
-    // Empty init() function is present by default in all Tact contracts
-    // since v1.3.0, so the following may be omitted:
-    //
-    // init() {}
+// Since v1.6.0, Tact has a contract parameters syntax that can supersede
+// lazy initialization by init() for all contracts that do not require specific on-chain
+// deployment logic that must be run only once in the `init()` function.
+//
+// Note that the empty parameter list above is still a parameter list,
+// meaning that the contract won't have an implicit or explicit `init(){:tact}` function
+// and will enjoy storage write optimizations and use less gas overall.
+//
+// See: https://docs.tact-lang.org/book/contracts/#parameters
+contract {{name}}() {
+    // Empty receiver for the deployment,
+    // which expects the `null` message body
+    receive() {
+        // Forward the remaining value in the
+        // incoming message back to the sender
+        cashback(sender());
+    }
 }

package/dist/templates/tact/empty/scripts/deploy.ts.template

@@ -11,10 +11,7 @@ export async function run(provider: NetworkProvider) {
         {
             value: toNano('0.05'),
         },
-        {
-            $$type: 'Deploy',
-            queryId: 0n,
-        }
+        null,
     );
 
     await provider.waitForDeploy({{loweredName}}.address);

package/dist/templates/tact/empty/tests/spec.ts.template

@@ -21,10 +21,7 @@ describe('{{name}}', () => {
             {
                 value: toNano('0.05'),
             },
-            {
-                $$type: 'Deploy',
-                queryId: 0n,
-            }
+            null,
         );
 
         expect(deployResult.transactions).toHaveTransaction({

package/dist/ui/UIProvider.d.ts

@@ -1,10 +1,68 @@
 import { Address } from '@ton/core';
+/**
+ * Interface for handling user interactions, such as displaying messages,
+ * prompting for input, and managing action prompts.
+ */
 export interface UIProvider {
+    /**
+     * Writes a message to the user interface (e.g., console or UI panel).
+     * @param {string} message - The message to display.
+     * @example
+     * const ui: UIProvider = ...
+     * ui.write("Transaction sent successfully.");
+     */
     write(message: string): void;
+    /**
+     * Prompts the user with a yes/no confirmation.
+     * @param {string} message - The message to display in the prompt.
+     * @returns {Promise<boolean>} A promise that resolves to true if the user confirms, otherwise false.
+     * @example
+     * const ui: UIProvider = ...
+     * const confirmed = await ui.prompt("Do you want to proceed?");
+     */
     prompt(message: string): Promise<boolean>;
+    /**
+     * Prompts the user to input a TON address.
+     * @param {string} message - The prompt message.
+     * @param {Address} [fallback] - A default address to use if the user provides no input.
+     * @returns {Promise<Address>} A promise that resolves to the input address.
+     * @example
+     * const ui: UIProvider = ...
+     * const address = await ui.inputAddress("Enter destination address:", myWalletAddress);
+     */
     inputAddress(message: string, fallback?: Address): Promise<Address>;
+    /**
+     * Prompts the user to input a string value.
+     * @param {string} message - The message to display in the prompt.
+     * @returns {Promise<string>} A promise that resolves to the user's input.
+     * @example
+     * const ui: UIProvider = ...
+     * const nickname = await ui.input("Enter your nickname:");
+     */
     input(message: string): Promise<string>;
+    /**
+     * Prompts the user to choose from a list of options.
+     * @param {string} message - The prompt message.
+     * @param {T[]} choices - An array of choices to select from.
+     * @param {(v: T) => string} display - A function that returns a string to display for each choice.
+     * @returns {Promise<T>} A promise that resolves to the selected item.
+     * @example
+     * const ui: UIProvider = ...
+     * const network = await ui.choose("Select a network:", ["mainnet", "testnet"], n => n.toUpperCase());
+     */
     choose<T>(message: string, choices: T[], display: (v: T) => string): Promise<T>;
+    /**
+     * Sets a persistent action prompt (e.g., status indicator) in the UI. New call of `setActionPrompt` will replace
+     * the previous action prompt.
+     * @param {string} message - The action message to display.
+     * @example
+     * ui.setActionPrompt("Awaiting transaction confirmation...");
+     */
     setActionPrompt(message: string): void;
+    /**
+     * Clears the current action prompt from the UI.
+     * @example
+     * ui.clearActionPrompt();
+     */
     clearActionPrompt(): void;
 }

package/dist/utils/ton.utils.d.ts

@@ -1,3 +1,31 @@
 import { Address, Cell } from '@ton/core';
+/**
+ * Generates a TON deep link for transfer.
+ *
+ * @param {Address} address - The recipient's TON address.
+ * @param {bigint} amount - The amount of nanoTON to send.
+ * @param {Cell} [body] - Optional message body as a Cell.
+ * @param {Cell} [stateInit] - Optional state init cell for deploying a contract.
+ * @returns {string} A URL deep link that can be opened in TON wallets.
+ *
+ * @example
+ * const link = tonDeepLink(myAddress, 10_000_000n); // 0.01 TON
+ * // "ton://transfer/..."
+ */
 export declare const tonDeepLink: (address: Address, amount: bigint, body?: Cell, stateInit?: Cell) => string;
+/**
+ * Generates a link to view a TON address in a selected blockchain explorer.
+ *
+ * Supports several TON explorers like TONSCan, Tonviewer, dton.io, etc., and
+ * dynamically adds the testnet prefix when needed.
+ *
+ * @param {string} address - The TON address to view in explorer.
+ * @param {string} network - The target network, either 'mainnet' or 'testnet'.
+ * @param {string} explorer - The desired explorer. Supported values: 'tonscan', 'tonviewer', 'toncx', 'dton'.
+ * @returns {string} A full URL pointing to the address in the selected explorer.
+ *
+ * @example
+ * const link = getExplorerLink("EQC...", "testnet", "tonscan");
+ * // "https://testnet.tonscan.org/address/EQC..."
+ */
 export declare function getExplorerLink(address: string, network: string, explorer: string): string;

package/dist/utils/ton.utils.js

@@ -1,11 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExplorerLink = exports.tonDeepLink = void 0;
+/**
+ * Generates a TON deep link for transfer.
+ *
+ * @param {Address} address - The recipient's TON address.
+ * @param {bigint} amount - The amount of nanoTON to send.
+ * @param {Cell} [body] - Optional message body as a Cell.
+ * @param {Cell} [stateInit] - Optional state init cell for deploying a contract.
+ * @returns {string} A URL deep link that can be opened in TON wallets.
+ *
+ * @example
+ * const link = tonDeepLink(myAddress, 10_000_000n); // 0.01 TON
+ * // "ton://transfer/..."
+ */
 const tonDeepLink = (address, amount, body, stateInit) => `ton://transfer/${address.toString({
     urlSafe: true,
     bounceable: true,
 })}?amount=${amount.toString()}${body ? '&bin=' + body.toBoc().toString('base64url') : ''}${stateInit ? '&init=' + stateInit.toBoc().toString('base64url') : ''}`;
 exports.tonDeepLink = tonDeepLink;
+/**
+ * Generates a link to view a TON address in a selected blockchain explorer.
+ *
+ * Supports several TON explorers like TONSCan, Tonviewer, dton.io, etc., and
+ * dynamically adds the testnet prefix when needed.
+ *
+ * @param {string} address - The TON address to view in explorer.
+ * @param {string} network - The target network, either 'mainnet' or 'testnet'.
+ * @param {string} explorer - The desired explorer. Supported values: 'tonscan', 'tonviewer', 'toncx', 'dton'.
+ * @returns {string} A full URL pointing to the address in the selected explorer.
+ *
+ * @example
+ * const link = getExplorerLink("EQC...", "testnet", "tonscan");
+ * // "https://testnet.tonscan.org/address/EQC..."
+ */
 function getExplorerLink(address, network, explorer) {
     const networkPrefix = network === 'testnet' ? 'testnet.' : '';
     switch (explorer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/blueprint",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Framework for development of TON smart contracts",
   "main": "dist/index.js",
   "bin": "./dist/cli/cli.js",
@@ -19,7 +19,7 @@
     "format": "prettier --write src"
   },
   "devDependencies": {
-    "@tact-lang/compiler": "^1.5.3",
+    "@tact-lang/compiler": "^1.6.5",
     "@ton-community/func-js": "^0.9.0",
     "@ton/core": "^0.59.0",
     "@ton/crypto": "^3.3.0",
@@ -32,7 +32,7 @@
     "typescript": "^4.9.5"
   },
   "peerDependencies": {
-    "@tact-lang/compiler": ">=1.5.3",
+    "@tact-lang/compiler": ">=1.6.5",
     "@ton-community/func-js": ">=0.9.0",
     "@ton/core": ">=0.59.0",
     "@ton/crypto": ">=3.3.0",