@ton/blueprint 0.32.1 → 0.33.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.33.0] - 2025-05-16
+
+### Added
+
+- Added `tact.config.json` support
+- Added tolk v0.12 support
+
+### Fixed
+
+- Fixed tact counter deploy script error
+
 ## [0.32.1] - 2025-05-06
 
 ### Fixed

package/dist/build.js

@@ -11,6 +11,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const compile_1 = require("./compile/compile");
 const paths_1 = require("./paths");
 const utils_1 = require("./utils");
+const tact_config_1 = require("./config/tact.config");
 async function buildOne(contract, ui) {
     ui?.write(`Build script running, compiling ${contract}`);
     const buildArtifactPath = path_1.default.join(paths_1.BUILD_DIR, `${contract}.compiled.json`);
@@ -69,17 +70,22 @@ async function buildOne(contract, ui) {
         }
     }
 }
-async function buildAll(ui) {
-    for (const file of await (0, utils_1.findCompiles)()) {
-        await buildOne(file.name, ui);
+async function buildContracts(contracts, ui) {
+    for (const contract of contracts) {
+        await buildOne(contract, ui);
     }
 }
+async function buildAll(ui) {
+    await buildContracts(await (0, utils_1.findContracts)(), ui);
+}
 async function buildAllTact(ui) {
-    // TODO: when tact config introduced rewrite to use it
-    for (const file of await (0, utils_1.findCompiles)()) {
-        const config = (0, compile_1.extractCompileConfig)(file.path);
-        if (config.lang === 'tact') {
-            await buildOne(file.name, ui);
-        }
-    }
+    const legacyTactContract = (await (0, utils_1.findCompiles)())
+        .filter((file) => (0, compile_1.extractCompilableConfig)(file.path).lang === 'tact')
+        .map((file) => file.name);
+    const tactConfig = (0, tact_config_1.getRootTactConfig)();
+    const tactContracts = [
+        ...legacyTactContract,
+        ...tactConfig.projects.map((project) => project.name),
+    ];
+    await buildContracts(tactContracts, ui);
 }

package/dist/cli/build.js

@@ -14,8 +14,7 @@ function extractBuildFile(args) {
     return args._.length > 1 && args._[1].length > 0 ? args._[1] : undefined;
 }
 async function selectContract(ui, hint, withAllOption = false) {
-    const compiles = await (0, utils_1.findCompiles)();
-    const contracts = compiles.map(compile => compile.name);
+    const contracts = await (0, utils_1.findContracts)();
     const options = contracts.map((contract) => ({ name: contract, value: contract }));
     const allContractsValue = 'all_contracts';
     if (withAllOption) {

package/dist/cli/create.js

@@ -4,14 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = void 0;
-const Runner_1 = require("./Runner");
-const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
-const template_1 = require("../template");
-const utils_1 = require("../utils");
+const promises_1 = require("fs/promises");
 const arg_1 = __importDefault(require("arg"));
+const utils_1 = require("../config/utils");
+const tact_config_1 = require("../config/tact.config");
+const Runner_1 = require("./Runner");
+const template_1 = require("../template");
+const utils_2 = require("../utils");
 const build_1 = require("../build");
-const utils_2 = require("../config/utils");
 const constants_1 = require("./constants");
 function toSnakeCase(v) {
     const r = v.replace(/[A-Z]/g, (sub) => '_' + sub.toLowerCase());
@@ -48,6 +49,31 @@ async function createFiles(templatePath, realPath, replaces) {
         }
     }
 }
+function getFileExtension(lang) {
+    if (lang === 'func')
+        return 'fc';
+    if (lang === 'tolk')
+        return 'tolk';
+    return 'tact';
+}
+function addToTactConfig(contractName, contractPath) {
+    const tactConfig = (0, tact_config_1.getRootTactConfig)();
+    const projectConfig = {
+        name: contractName,
+        path: contractPath,
+        output: path_1.default.join('build', contractName),
+        options: {
+            debug: false,
+            external: false,
+        },
+        mode: 'full',
+    };
+    const newConfig = {
+        ...tactConfig,
+        projects: [...tactConfig.projects, projectConfig],
+    };
+    (0, tact_config_1.updateRootTactConfig)(newConfig);
+}
 const create = async (args, ui) => {
     const localArgs = (0, arg_1.default)({
         '--type': String,
@@ -57,35 +83,39 @@ const create = async (args, ui) => {
         ui.write(constants_1.helpMessages['create']);
         return;
     }
-    const name = (0, Runner_1.extractFirstArg)(localArgs)
-        ?? await ui.input('Contract name (PascalCase)');
+    const name = (0, Runner_1.extractFirstArg)(localArgs) ?? (await ui.input('Contract name (PascalCase)'));
     if (name.length === 0)
         throw new Error(`Cannot create a contract with an empty name`);
     if (name.toLowerCase() === 'contract') {
         throw new Error(`Cannot create a contract with the reserved name 'contract'. Please choose a different name.`);
     }
-    if (!(0, utils_1.isPascalCase)(name)) {
-        throw new Error(`Contract name '${name}' is not in PascalCase. Please try ${(0, utils_1.toPascalCase)(name)}.`);
+    if (!(0, utils_2.isPascalCase)(name)) {
+        throw new Error(`Contract name '${name}' is not in PascalCase. Please try ${(0, utils_2.toPascalCase)(name)}.`);
     }
-    const which = (await (0, utils_1.selectOption)(constants_1.templateTypes, {
+    const which = (await (0, utils_2.selectOption)(constants_1.templateTypes, {
         ui,
         msg: 'What type of contract do you want to create?',
         hint: localArgs['--type'],
     })).value;
     const [lang, template] = which.split('-');
     const snakeName = toSnakeCase(name);
+    const contractPath = path_1.default.join('contracts', snakeName + '.' + getFileExtension(lang));
     const replaces = {
         name,
         loweredName: name.substring(0, 1).toLowerCase() + name.substring(1),
         snakeName,
-        contractPath: 'contracts/' + snakeName + '.' + (lang === 'func' ? 'fc' : (lang === 'tolk' ? 'tolk' : 'tact')),
+        contractPath,
     };
-    const config = await (0, utils_2.getConfig)();
-    const commonPath = config?.separateCompilables ? 'common' : 'not-separated-common';
-    await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, commonPath), process.cwd(), replaces);
-    await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, template), process.cwd(), replaces);
+    const config = await (0, utils_1.getConfig)();
     if (lang === 'tact') {
+        await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, template), process.cwd(), replaces);
+        addToTactConfig(name, contractPath);
         await (0, build_1.buildOne)(name, ui);
     }
+    else {
+        const commonPath = config?.separateCompilables ? 'common' : 'not-separated-common';
+        await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, commonPath), process.cwd(), replaces);
+        await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, template), process.cwd(), replaces);
+    }
 };
 exports.create = create;

package/dist/compile/CompilerConfig.d.ts

@@ -1,6 +1,7 @@
-import { SourceResolver, SourcesMap, SourcesArray } from '@ton-community/func-js';
 import { Cell } from '@ton/core';
-import { Options } from '@tact-lang/compiler';
+import { TolkCompilerConfig } from './tolk/config';
+import { FuncCompilerConfig } from './func/config';
+import { TactCompilerConfig, TactLegacyCompilerConfig } from './tact/config';
 export type HookParams = {
     userData?: any;
 };
@@ -33,26 +34,6 @@ export type CommonCompilerConfig = {
      */
     postCompileHook?: (code: Cell, params: HookParams) => Promise<void>;
 };
-export type TactCompilerConfig = {
-    lang: 'tact';
-    target: string;
-    options?: Options;
-};
-export type FuncCompilerConfig = {
-    lang?: 'func';
-    optLevel?: number;
-} & ({
-    targets: string[];
-    sources?: SourceResolver | SourcesMap;
-} | {
-    targets?: string[];
-    sources: SourcesArray;
-});
-export type TolkCompilerConfig = {
-    lang: 'tolk';
-    entrypoint: string;
-    optimizationLevel?: number;
-    withStackComments?: boolean;
-    experimentalOptions?: string;
-};
-export type CompilerConfig = (TactCompilerConfig | FuncCompilerConfig | TolkCompilerConfig) & CommonCompilerConfig;
+export type CompilableConfig = (TactLegacyCompilerConfig | FuncCompilerConfig | TolkCompilerConfig) & CommonCompilerConfig;
+export type CompilerConfig = TactCompilerConfig | CompilableConfig;
+export declare function isCompilableConfig(config: CompilerConfig): config is CompilableConfig;

package/dist/compile/CompilerConfig.js

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompilableConfig = isCompilableConfig;
+function isCompilableConfig(config) {
+    return 'lang' in config;
+}

package/dist/compile/SourceSnapshot.d.ts

@@ -0,0 +1,4 @@
+export type SourceSnapshot = {
+    filename: string;
+    content: string;
+};

package/dist/compile/SourceSnapshot.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compile/compile.d.ts

@@ -1,37 +1,12 @@
 import { Cell } from '@ton/core';
-import { CompilerConfig, TactCompilerConfig } from './CompilerConfig';
+import { CompilableConfig, CompilerConfig } from './CompilerConfig';
+import { FuncCompileResult } from './func/compile.func';
+import { TactCompileResult } from './tact/compile.tact';
+import { TolkCompileResult } from './tolk/compile.tolk';
 export declare function getCompilablesDirectory(): Promise<string>;
+export declare function extractCompilableConfig(path: string): CompilableConfig;
 export declare const COMPILE_END = ".compile.ts";
-export declare function extractCompileConfig(path: string): CompilerConfig;
 export declare function getCompilerConfigForContract(name: string): Promise<CompilerConfig>;
-export type SourceSnapshot = {
-    filename: string;
-    content: string;
-};
-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[];
-    version: string;
-};
-export type TactCompileResult = {
-    lang: 'tact';
-    fs: Map<string, Buffer>;
-    code: Cell;
-    options?: TactCompilerConfig['options'];
-    version: string;
-};
-export declare function getTactVersion(): Promise<any>;
 export type CompileResult = TactCompileResult | FuncCompileResult | TolkCompileResult;
 export declare function getCompilerOptions(config: CompilerConfig): Promise<{
     lang: 'tact' | 'tolk' | 'func';
@@ -71,3 +46,4 @@ export type CompileOpts = {
  * main();
  */
 export declare function compile(name: string, opts?: CompileOpts): Promise<Cell>;
+export type { TactCompileResult, TolkCompileResult, FuncCompileResult };

package/dist/compile/compile.js

@@ -1,58 +1,23 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPILE_END = void 0;
 exports.getCompilablesDirectory = getCompilablesDirectory;
-exports.extractCompileConfig = extractCompileConfig;
+exports.extractCompilableConfig = extractCompilableConfig;
 exports.getCompilerConfigForContract = getCompilerConfigForContract;
-exports.getTactVersion = getTactVersion;
 exports.getCompilerOptions = getCompilerOptions;
 exports.doCompile = doCompile;
 exports.compile = compile;
-const func_js_1 = require("@ton-community/func-js");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
-const core_1 = require("@ton/core");
 const paths_1 = require("../paths");
-const Tact = __importStar(require("@tact-lang/compiler"));
-const OverwritableVirtualFileSystem_1 = require("./OverwritableVirtualFileSystem");
+const CompilerConfig_1 = require("./CompilerConfig");
 const utils_1 = require("../config/utils");
-const tolk_js_1 = require("@ton/tolk-js");
+const compile_func_1 = require("./func/compile.func");
+const compile_tact_1 = require("./tact/compile.tact");
+const compile_tolk_1 = require("./tolk/compile.tolk");
 async function getCompilablesDirectory() {
     const config = await (0, utils_1.getConfig)();
     if (config?.separateCompilables) {
@@ -60,141 +25,64 @@ async function getCompilablesDirectory() {
     }
     return paths_1.WRAPPERS_DIR;
 }
-exports.COMPILE_END = '.compile.ts';
-function extractCompileConfig(path) {
+function extractCompilableConfig(path) {
     const mod = require(path);
     if (typeof mod.compile !== 'object') {
         throw new Error(`Object 'compile' is missing`);
     }
+    mod.compile.lang ??= 'func';
     return mod.compile;
 }
+exports.COMPILE_END = '.compile.ts';
+// contracts in tact.config.json and .compile.ts may overlap. In this case configuration from tact.config.json would be taken
 async function getCompilerConfigForContract(name) {
-    const compilablesDirectory = await getCompilablesDirectory();
-    return extractCompileConfig(path_1.default.join(compilablesDirectory, name + exports.COMPILE_END));
-}
-async function doCompileTolk(config) {
-    const res = await (0, tolk_js_1.runTolkCompiler)(config);
-    if (res.status === 'error') {
-        throw new Error(res.message);
+    const tactConfig = (0, compile_tact_1.getTactConfigForContract)(name);
+    if (tactConfig) {
+        return tactConfig;
     }
-    return {
-        lang: 'tolk',
-        stderr: res.stderr,
-        fiftCode: res.fiftCode,
-        code: core_1.Cell.fromBase64(res.codeBoc64),
-        snapshot: res.sourcesSnapshot.map((e) => ({
-            filename: e.filename,
-            content: e.contents,
-        })),
-        version: await (0, tolk_js_1.getTolkCompilerVersion)(),
-    };
-}
-async function doCompileFunc(config) {
-    const cr = await (0, func_js_1.compileFunc)(config);
-    if (cr.status === 'error')
-        throw new Error(cr.message);
-    let targets = [];
-    if (config.targets) {
-        targets = config.targets;
-    }
-    else if (Array.isArray(config.sources)) {
-        targets = config.sources.map((s) => s.filename);
-    }
-    return {
-        lang: 'func',
-        fiftCode: cr.fiftCode,
-        code: core_1.Cell.fromBase64(cr.codeBoc),
-        targets,
-        snapshot: cr.snapshot,
-        version: (await (0, func_js_1.compilerVersion)()).funcVersion,
-    };
+    const compilablesDirectory = await getCompilablesDirectory();
+    return extractCompilableConfig(path_1.default.join(compilablesDirectory, name + exports.COMPILE_END));
 }
-function findTactBoc(fs) {
-    let buf = undefined;
-    for (const [k, v] of fs) {
-        if (k.endsWith('.code.boc')) {
-            buf = v;
-            break;
+async function doCompileInner(name, config) {
+    if ((0, CompilerConfig_1.isCompilableConfig)(config)) {
+        if (config.lang === 'tact') {
+            return await (0, compile_tact_1.doCompileTact)(config, name);
         }
-    }
-    if (buf === undefined) {
-        throw new Error('Could not find boc in tact compilation result');
-    }
-    return core_1.Cell.fromBoc(buf)[0];
-}
-function getRootTactConfigOptionsForContract(name) {
-    if (!(0, fs_1.existsSync)(paths_1.TACT_ROOT_CONFIG)) {
-        return undefined;
-    }
-    const config = Tact.parseConfig((0, fs_1.readFileSync)(paths_1.TACT_ROOT_CONFIG).toString());
-    for (const project of config.projects) {
-        if (project.name === name) {
-            return project.options;
+        if (config.lang === 'tolk') {
+            return await (0, compile_tolk_1.doCompileTolk)({
+                entrypointFileName: config.entrypoint,
+                fsReadCallback: (path) => (0, fs_1.readFileSync)(path).toString(),
+                optimizationLevel: config.optimizationLevel,
+                withStackComments: config.withStackComments,
+                withSrcLineComments: config.withSrcLineComments,
+                experimentalOptions: config.experimentalOptions,
+            });
         }
-    }
-    return undefined;
-}
-async function getTactVersion() {
-    const packageJsonPath = require.resolve('@tact-lang/compiler/package.json');
-    const { version } = await Promise.resolve(`${packageJsonPath}`).then(s => __importStar(require(s)));
-    return version;
-}
-async function doCompileTact(config, name) {
-    const rootConfigOptions = getRootTactConfigOptionsForContract(name);
-    const fs = new OverwritableVirtualFileSystem_1.OverwritableVirtualFileSystem(process.cwd());
-    const buildConfig = {
-        config: {
-            name: 'tact',
-            path: config.target,
-            output: path_1.default.join(paths_1.BUILD_DIR, name),
-            options: { ...rootConfigOptions, ...config.options },
-        },
-        stdlib: Tact.createVirtualFileSystem("@stdlib", Tact.stdLibFiles),
-        project: fs,
-    };
-    const res = await Tact.build(buildConfig);
-    if (!res.ok) {
-        throw new Error('Could not compile tact');
-    }
-    const code = findTactBoc(fs.overwrites);
-    return {
-        lang: 'tact',
-        fs: fs.overwrites,
-        code,
-        options: buildConfig.config.options,
-        version: await getTactVersion(),
-    };
-}
-async function doCompileInner(name, config) {
-    if (config.lang === 'tact') {
-        return await doCompileTact(config, name);
-    }
-    if (config.lang === 'tolk') {
-        return await doCompileTolk({
-            entrypointFileName: config.entrypoint,
-            fsReadCallback: (path) => (0, fs_1.readFileSync)(path).toString(),
-            optimizationLevel: config.optimizationLevel,
-            withStackComments: config.withStackComments,
-            experimentalOptions: config.experimentalOptions,
+        return await (0, compile_func_1.doCompileFunc)({
+            targets: config.targets,
+            sources: config.sources ?? ((path) => (0, fs_1.readFileSync)(path).toString()),
+            optLevel: config.optLevel,
         });
     }
-    return await doCompileFunc({
-        targets: config.targets,
-        sources: config.sources ?? ((path) => (0, fs_1.readFileSync)(path).toString()),
-        optLevel: config.optLevel,
-    });
+    return await (0, compile_tact_1.doCompileTact)(config, name);
 }
 function getCompilerName(config) {
-    return config.lang ?? 'func';
+    if ((0, CompilerConfig_1.isCompilableConfig)(config)) {
+        return config.lang ?? 'func';
+    }
+    return 'tact';
 }
 async function getCompilerVersion(config) {
-    if (config.lang === 'tact') {
-        return getTactVersion();
-    }
-    if (config.lang === 'tolk') {
-        return (0, tolk_js_1.getTolkCompilerVersion)();
+    if ((0, CompilerConfig_1.isCompilableConfig)(config)) {
+        if (config.lang === 'tact') {
+            return (0, compile_tact_1.getTactVersion)();
+        }
+        if (config.lang === 'tolk') {
+            return (0, compile_tolk_1.getTolkVersion)();
+        }
+        return (0, compile_func_1.getFuncVersion)();
     }
-    return (await (0, func_js_1.compilerVersion)()).funcVersion;
+    return (0, compile_tact_1.getTactVersion)();
 }
 async function getCompilerOptions(config) {
     return {
@@ -204,13 +92,13 @@ async function getCompilerOptions(config) {
 }
 async function doCompile(name, opts) {
     const config = await getCompilerConfigForContract(name);
-    if (config.preCompileHook !== undefined) {
+    if ('preCompileHook' in config && config.preCompileHook !== undefined) {
         await config.preCompileHook({
             userData: opts?.hookUserData,
         });
     }
     const res = await doCompileInner(name, config);
-    if (config.postCompileHook !== undefined) {
+    if ('postCompileHook' in config && config.postCompileHook !== undefined) {
         await config.postCompileHook(res.code, {
             userData: opts?.hookUserData,
         });

package/dist/compile/func/compile.func.d.ts

@@ -0,0 +1,14 @@
+import { Cell } from '@ton/core';
+import { CompilerConfig } from '@ton-community/func-js';
+import { SourceSnapshot } from '../SourceSnapshot';
+export type FuncCompileResult = {
+    lang: 'func';
+    fiftCode: string;
+    code: Cell;
+    targets: string[];
+    snapshot: SourceSnapshot[];
+    version: string;
+};
+export declare function getFuncVersion(): Promise<string>;
+export declare function doCompileFunc(config: CompilerConfig): Promise<FuncCompileResult>;
+export { CompilerConfig as DoCompileFuncConfig } from '@ton-community/func-js';

package/dist/compile/func/compile.func.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFuncVersion = getFuncVersion;
+exports.doCompileFunc = doCompileFunc;
+const core_1 = require("@ton/core");
+const func_js_1 = require("@ton-community/func-js");
+async function getFuncVersion() {
+    return (await (0, func_js_1.compilerVersion)()).funcVersion;
+}
+async function doCompileFunc(config) {
+    const cr = await (0, func_js_1.compileFunc)(config);
+    if (cr.status === 'error')
+        throw new Error(cr.message);
+    let targets = [];
+    if (config.targets) {
+        targets = config.targets;
+    }
+    else if (Array.isArray(config.sources)) {
+        targets = config.sources.map((s) => s.filename);
+    }
+    return {
+        lang: 'func',
+        fiftCode: cr.fiftCode,
+        code: core_1.Cell.fromBase64(cr.codeBoc),
+        targets,
+        snapshot: cr.snapshot,
+        version: await getFuncVersion(),
+    };
+}

package/dist/compile/func/config.d.ts

@@ -0,0 +1,11 @@
+import { SourceResolver, SourcesArray, SourcesMap } from '@ton-community/func-js';
+export type FuncCompilerConfig = {
+    lang?: 'func';
+    optLevel?: number;
+} & ({
+    targets: string[];
+    sources?: SourceResolver | SourcesMap;
+} | {
+    targets?: string[];
+    sources: SourcesArray;
+});

package/dist/compile/func/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compile/tact/compile.tact.d.ts

@@ -0,0 +1,13 @@
+import { Options } from '@tact-lang/compiler';
+import { Cell } from '@ton/core';
+import { TactCompilerConfig, TactLegacyCompilerConfig } from './config';
+export type TactCompileResult = {
+    lang: 'tact';
+    fs: Map<string, Buffer>;
+    code: Cell;
+    options?: Options;
+    version: string;
+};
+export declare function getTactConfigForContract(name: string): TactCompilerConfig | undefined;
+export declare function getTactVersion(): Promise<any>;
+export declare function doCompileTact(config: TactLegacyCompilerConfig | TactCompilerConfig, name: string): Promise<TactCompileResult>;

package/dist/compile/tact/compile.tact.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTactConfigForContract = getTactConfigForContract;
+exports.getTactVersion = getTactVersion;
+exports.doCompileTact = doCompileTact;
+const path_1 = __importDefault(require("path"));
+const compiler_1 = require("@tact-lang/compiler");
+const core_1 = require("@ton/core");
+const paths_1 = require("../../paths");
+const OverwritableVirtualFileSystem_1 = require("./OverwritableVirtualFileSystem");
+const tact_config_1 = require("../../config/tact.config");
+function findTactBoc(fs) {
+    let buf = undefined;
+    for (const [k, v] of fs) {
+        if (k.endsWith('.code.boc')) {
+            buf = v;
+            break;
+        }
+    }
+    if (buf === undefined) {
+        throw new Error('Could not find boc in tact compilation result');
+    }
+    return core_1.Cell.fromBoc(buf)[0];
+}
+function getTactConfigForContract(name) {
+    const config = (0, tact_config_1.getRootTactConfig)();
+    const projects = config.projects.filter((project) => project.name === name);
+    if (!projects.length) {
+        return;
+    }
+    return {
+        ...config,
+        projects,
+    };
+}
+function getRootTactConfigOptionsForContract(name) {
+    const filteredTactConfig = getTactConfigForContract(name);
+    if (!filteredTactConfig) {
+        return;
+    }
+    const [project] = filteredTactConfig.projects;
+    return project?.options;
+}
+async function getTactVersion() {
+    const packageJsonPath = require.resolve('@tact-lang/compiler/package.json');
+    const { version } = await Promise.resolve(`${packageJsonPath}`).then(s => __importStar(require(s)));
+    return version;
+}
+function isLegacyTactConfig(config) {
+    return 'lang' in config;
+}
+function getTactBuildProject(config, name) {
+    if (isLegacyTactConfig(config)) {
+        const rootConfigOptions = getRootTactConfigOptionsForContract(name);
+        return {
+            name: 'tact',
+            path: config.target,
+            output: path_1.default.join(paths_1.BUILD_DIR, name),
+            options: { ...rootConfigOptions, ...config.options },
+        };
+    }
+    const project = config.projects.find((p) => p.name === name);
+    if (!project) {
+        throw new Error(`Config for project ${name} not found`);
+    }
+    return project;
+}
+async function doCompileTact(config, name) {
+    const fs = new OverwritableVirtualFileSystem_1.OverwritableVirtualFileSystem(process.cwd());
+    const buildConfig = {
+        config: getTactBuildProject(config, name),
+        stdlib: (0, compiler_1.createVirtualFileSystem)('@stdlib', compiler_1.stdLibFiles),
+        project: fs,
+    };
+    const res = await (0, compiler_1.build)(buildConfig);
+    if (!res.ok) {
+        throw new Error('Could not compile tact');
+    }
+    const code = findTactBoc(fs.overwrites);
+    return {
+        lang: 'tact',
+        fs: fs.overwrites,
+        code,
+        options: buildConfig.config.options,
+        version: await getTactVersion(),
+    };
+}

package/dist/compile/tact/config.d.ts

@@ -0,0 +1,7 @@
+import { Config, Options } from '@tact-lang/compiler';
+export type TactLegacyCompilerConfig = {
+    lang: 'tact';
+    target: string;
+    options?: Options;
+};
+export type TactCompilerConfig = Config;

package/dist/compile/tact/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compile/tolk/compile.tolk.d.ts

@@ -0,0 +1,13 @@
+import { Cell } from '@ton/core';
+import { TolkCompilerConfig } from '@ton/tolk-js';
+import { SourceSnapshot } from '../SourceSnapshot';
+export type TolkCompileResult = {
+    lang: 'tolk';
+    stderr: string;
+    fiftCode: string;
+    code: Cell;
+    snapshot: SourceSnapshot[];
+    version: string;
+};
+export declare function doCompileTolk(config: TolkCompilerConfig): Promise<TolkCompileResult>;
+export { getTolkCompilerVersion as getTolkVersion } from '@ton/tolk-js';

package/dist/compile/tolk/compile.tolk.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTolkVersion = void 0;
+exports.doCompileTolk = doCompileTolk;
+const core_1 = require("@ton/core");
+const tolk_js_1 = require("@ton/tolk-js");
+async function doCompileTolk(config) {
+    const res = await (0, tolk_js_1.runTolkCompiler)(config);
+    if (res.status === 'error') {
+        throw new Error(res.message);
+    }
+    return {
+        lang: 'tolk',
+        stderr: res.stderr,
+        fiftCode: res.fiftCode,
+        code: core_1.Cell.fromBase64(res.codeBoc64),
+        snapshot: res.sourcesSnapshot.map((e) => ({
+            filename: e.filename,
+            content: e.contents,
+        })),
+        version: await (0, tolk_js_1.getTolkCompilerVersion)(),
+    };
+}
+var tolk_js_2 = require("@ton/tolk-js");
+Object.defineProperty(exports, "getTolkVersion", { enumerable: true, get: function () { return tolk_js_2.getTolkCompilerVersion; } });

package/dist/compile/tolk/config.d.ts

@@ -0,0 +1,8 @@
+export type TolkCompilerConfig = {
+    lang: 'tolk';
+    entrypoint: string;
+    optimizationLevel?: number;
+    withStackComments?: boolean;
+    withSrcLineComments?: boolean;
+    experimentalOptions?: string;
+};

package/dist/compile/tolk/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/tact.config.d.ts

@@ -0,0 +1,5 @@
+import { Config as TactConfig } from '@tact-lang/compiler';
+export declare const defaultConfig: TactConfig;
+export declare function getRootTactConfig(): TactConfig;
+export declare function updateRootTactConfig(config: TactConfig): void;
+export { TactConfig };

package/dist/config/tact.config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = void 0;
+exports.getRootTactConfig = getRootTactConfig;
+exports.updateRootTactConfig = updateRootTactConfig;
+const fs_1 = require("fs");
+const compiler_1 = require("@tact-lang/compiler");
+const paths_1 = require("../paths");
+exports.defaultConfig = {
+    $schema: 'https://raw.githubusercontent.com/tact-lang/tact/main/src/config/configSchema.json',
+    projects: [],
+};
+function getRootTactConfig() {
+    if (!(0, fs_1.existsSync)(paths_1.TACT_ROOT_CONFIG)) {
+        return exports.defaultConfig;
+    }
+    return (0, compiler_1.parseConfig)((0, fs_1.readFileSync)(paths_1.TACT_ROOT_CONFIG).toString());
+}
+function updateRootTactConfig(config) {
+    (0, fs_1.writeFileSync)(paths_1.TACT_ROOT_CONFIG, JSON.stringify(config, null, 2), 'utf-8');
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { tonDeepLink, sleep } from './utils';
 export { NetworkProvider } from './network/NetworkProvider';
 export { createNetworkProvider } from './network/createNetworkProvider';
-export { compile, CompileOpts, SourceSnapshot, TolkCompileResult, FuncCompileResult, TactCompileResult, CompileResult } from './compile/compile';
+export { compile, CompileOpts, TolkCompileResult, FuncCompileResult, TactCompileResult, CompileResult } from './compile/compile';
 export { CompilerConfig, HookParams } from './compile/CompilerConfig';
 export { UIProvider } from './ui/UIProvider';
 export { Config } from './config/Config';
@@ -9,3 +9,4 @@ export { Args, Runner, RunnerContext } from './cli/Runner';
 export { PluginRunner, Plugin } from './config/Plugin';
 export { CustomNetwork } from './config/CustomNetwork';
 export { buildOne, buildAll, buildAllTact } from './build';
+export { SourceSnapshot } from "./compile/SourceSnapshot";

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

@@ -4,7 +4,7 @@ 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))), 0n);
+    const {{loweredName}} = provider.open(await {{name}}.fromInit(BigInt(Math.floor(Math.random() * 10000)), 0n));
 
     await {{loweredName}}.send(
         provider.sender(),

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

@@ -1,7 +1,7 @@
 {{name}}.spec.ts
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
 import { toNano } from '@ton/core';
-import { {{name}} } from '../wrappers/{{name}}';
+import { {{name}} } from '../build/{{name}}/{{name}}_{{name}}';
 import '@ton/test-utils';
 
 describe('{{name}}', () => {

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

@@ -1,7 +1,7 @@
 {{name}}.spec.ts
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
 import { toNano } from '@ton/core';
-import { {{name}} } from '../wrappers/{{name}}';
+import { {{name}} } from '../build/{{name}}/{{name}}_{{name}}';
 import '@ton/test-utils';
 
 describe('{{name}}', () => {

package/dist/templates/tolk/common/compilables/compile.ts.template

@@ -5,5 +5,6 @@ export const compile: CompilerConfig = {
     lang: 'tolk',
     entrypoint: '{{contractPath}}',
     withStackComments: true,    // Fift output will contain comments, if you wish to debug its output
+    withSrcLineComments: true,  // Fift output will contain .tolk lines as comments
     experimentalOptions: '',    // you can pass experimental compiler options here
 };

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

@@ -12,17 +12,17 @@ global ctxCounter: int;
 
 // loadData populates storage variables from persistent storage
 fun loadData() {
-    var ds = getContractData().beginParse();
+    var ds = contract.getData().beginParse();
 
     ctxID = ds.loadUint(32);
     ctxCounter = ds.loadUint(32);
 
-    ds.assertEndOfSlice();
+    ds.assertEnd();
 }
 
 // saveData stores storage variables as a cell into persistent storage
 fun saveData() {
-    setContractData(
+    contract.setData(
         beginCell()
         .storeUint(ctxID, 32)
         .storeUint(ctxCounter, 32)
@@ -32,7 +32,7 @@ fun saveData() {
 
 // onInternalMessage is the main entrypoint; it's called when a contract receives an internal message from other contracts
 fun onInternalMessage(myBalance: int, msgValue: int, msgFull: cell, msgBody: slice) {
-    if (msgBody.isEndOfSlice()) { // ignore all empty messages
+    if (msgBody.isEnd()) { // ignore all empty messages
         return;
     }
 

package/dist/templates/tolk/not-separated-common/wrappers/compile.ts.template

@@ -5,5 +5,6 @@ export const compile: CompilerConfig = {
     lang: 'tolk',
     entrypoint: '{{contractPath}}',
     withStackComments: true,    // Fift output will contain comments, if you wish to debug its output
+    withSrcLineComments: true,  // Fift output will contain .tolk lines as comments
     experimentalOptions: '',    // you can pass experimental compiler options here
 };

package/dist/utils/object.utils.d.ts

@@ -1,3 +1,4 @@
 export declare function oneOrZeroOf<T extends {
     [k: string]: boolean | undefined;
 }>(options: T): keyof T | undefined;
+export declare function distinct<T>(values: T[]): T[];

package/dist/utils/object.utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.oneOrZeroOf = oneOrZeroOf;
+exports.distinct = distinct;
 function oneOrZeroOf(options) {
     let opt = undefined;
     for (const k in options) {
@@ -15,3 +16,6 @@ function oneOrZeroOf(options) {
     }
     return opt;
 }
+function distinct(values) {
+    return [...new Set(values)];
+}

package/dist/utils/selection.utils.d.ts

@@ -1,6 +1,7 @@
 import { UIProvider } from '../ui/UIProvider';
 import { File } from '../types/file';
 export declare const findCompiles: (directory?: string) => Promise<File[]>;
+export declare const findContracts: () => Promise<string[]>;
 export declare const findScripts: () => Promise<File[]>;
 export declare function selectOption(options: {
     name: string;

package/dist/utils/selection.utils.js

@@ -36,15 +36,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findScripts = exports.findCompiles = void 0;
+exports.findScripts = exports.findContracts = exports.findCompiles = void 0;
 exports.selectOption = selectOption;
 exports.selectFile = selectFile;
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
-const paths_1 = require("../paths");
+const tact_config_1 = require("../config/tact.config");
 const compile_1 = require("../compile/compile");
+const paths_1 = require("../paths");
+const object_utils_1 = require("./object.utils");
 const findCompiles = async (directory) => {
-    const dir = directory ?? await (0, compile_1.getCompilablesDirectory)();
+    const dir = directory ?? (await (0, compile_1.getCompilablesDirectory)());
     const files = await promises_1.default.readdir(dir);
     const compilables = files.filter((file) => file.endsWith(compile_1.COMPILE_END));
     return compilables.map((file) => ({
@@ -53,6 +55,15 @@ const findCompiles = async (directory) => {
     }));
 };
 exports.findCompiles = findCompiles;
+const findContracts = async () => {
+    const compilables = await (0, exports.findCompiles)();
+    const tactRootConfig = (0, tact_config_1.getRootTactConfig)();
+    return (0, object_utils_1.distinct)([
+        ...compilables.map((file) => file.name),
+        ...(tactRootConfig?.projects.map((project) => project.name) ?? []),
+    ]);
+};
+exports.findContracts = findContracts;
 const findScripts = async () => {
     const dirents = await promises_1.default.readdir(paths_1.SCRIPTS_DIR, { recursive: true, withFileTypes: true });
     const scripts = dirents.filter((dirent) => dirent.isFile() && dirent.name.endsWith('.ts'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/blueprint",
-  "version": "0.32.1",
+  "version": "0.33.0",
   "description": "Framework for development of TON smart contracts",
   "main": "dist/index.js",
   "bin": "./dist/cli/cli.js",
@@ -23,7 +23,7 @@
     "@ton-community/func-js": "^0.9.0",
     "@ton/core": "^0.59.0",
     "@ton/crypto": "^3.3.0",
-    "@ton/tolk-js": "^0.6.0",
+    "@ton/tolk-js": "^0.12.0",
     "@ton/ton": "^15.0.0",
     "@types/inquirer": "^8.2.6",
     "@types/node": "^20.2.5",
@@ -36,7 +36,7 @@
     "@ton-community/func-js": ">=0.9.0",
     "@ton/core": ">=0.59.0",
     "@ton/crypto": ">=3.3.0",
-    "@ton/tolk-js": ">=0.6.0",
+    "@ton/tolk-js": ">=0.12.0",
     "@ton/ton": ">=15.0.0"
   },
   "dependencies": {

package/dist/templates/tact/common/compilables/compile.ts.template

@@ -1,10 +0,0 @@
-{{name}}.compile.ts
-import { CompilerConfig } from '@ton/blueprint';
-
-export const compile: CompilerConfig = {
-    lang: 'tact',
-    target: '{{contractPath}}',
-    options: {
-        debug: true,
-    },
-};

package/dist/templates/tact/common/wrappers/wrapper.ts.template

@@ -1,2 +0,0 @@
-{{name}}.ts
-export * from '../build/{{name}}/tact_{{name}}';

package/dist/templates/tact/not-separated-common/wrappers/compile.ts.template

@@ -1,10 +0,0 @@
-{{name}}.compile.ts
-import { CompilerConfig } from '@ton/blueprint';
-
-export const compile: CompilerConfig = {
-    lang: 'tact',
-    target: '{{contractPath}}',
-    options: {
-        debug: true,
-    },
-};

package/dist/templates/tact/not-separated-common/wrappers/wrapper.ts.template

@@ -1,2 +0,0 @@
-{{name}}.ts
-export * from '../build/{{name}}/tact_{{name}}';