@ton/blueprint 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.17.0] - 2024-03-01
+
+This release contains a breaking change.
+
+### Changed
+
+- Blueprint no longer automatically adds `jsonRPC` to custom v2 endpoints
+
+### Added
+
+- Added `set` command which can currently set func version (run `blueprint set func`)
+- Added `open` and `getTransactions` to `WrappedContractProvider`
+- Added cell hash to build artifacts
+
+## [0.16.0] - 2024-02-15
+
+### Added
+
+- Added the `network` entry to the global config, which allows one to specify a custom network to be used instead of having to add `--custom` flags on each run
+- Added the `convert` command which attempts to convert a legacy bash build script into a blueprint `.compile.ts` file
+- Added the ability to pass any user data into the compile hooks
+
+### Changed
+
+- Improved the `verify` command
+
 ## [0.15.0] - 2023-12-15
 
 ### Added

package/README.md

@@ -103,26 +103,61 @@ Run in terminal:   `npx blueprint help`   or   `yarn blueprint he
 2. Implement a deployment script in `scripts/deploy<CONTRACT>.ts`
 3. Rely on the wrapper TypeScript class from `wrappers/<CONTRACT>.ts` to initialize the contract
 
-## Plugins
+## Config
+
+A config may be created in order to control some of blueprint's features. If a config is needed, create a `blueprint.config.ts` file in the root of your project with something like this:
+```typescript
+import { Config } from '@ton/blueprint';
+
+export const config: Config = {
+    // config contents
+};
+```
+It is important that the config is exported, is named `config`, and is not `default` exported.
+
+Config's features are explained below.
+
+### Plugins
 
 Blueprint has a plugin system to allow the community to develop their own additions for the ecosystem without the need to change blueprint's code.
 
-In order to use plugins, create a `blueprint.config.ts` file in the root of your project with something like this:
+In order to use plugins, add a `plugins` array to your config:
 ```typescript
 import { Config } from '@ton/blueprint';
 import { ScaffoldPlugin } from 'blueprint-scaffold';
 
 export const config: Config = {
-   plugins: [new ScaffoldPlugin()],
+    plugins: [new ScaffoldPlugin()],
 };
 ```
 (This example shows how to add the [scaffold](https://github.com/1IxI1/blueprint-scaffold) plugin)
 
-It is important that the config is exported, is named `config`, and is not `default` exported.
-
 Here are some of the plugins developed by the community:
 - [scaffold](https://github.com/1IxI1/blueprint-scaffold) - allows developers to quickly create a simple dapp automatically using the wrappers' code
 
+### Custom network
+
+A custom network may be specified by using the `--custom` flags, which you can read about by running `blueprint help run`, but it can be tiresome to use these at all times. Instead, to specify a custom network to always be used (unless `--custom` flags are present), add a `network` object to your config:
+```typescript
+import { Config } from '@ton/blueprint';
+
+export const config: Config = {
+    network: {
+        endpoint: 'https://toncenter.com/api/v2/',
+        type: 'mainnet',
+        version: 'v2',
+        key: 'YOUR_API_KEY',
+    },
+};
+```
+
+The above config parameters are equivalent to the arguments in the following command:
+```bash
+npx blueprint run --custom https://toncenter.com/api/v2/ --custom-version v2 --custom-type mainnet --custom-key YOUR_API_KEY
+```
+
+Properties of the `network` object have the same semantics as the `--custom` flags with respective names (see `blueprint help run`).
+
 ## Contributors
 
 Special thanks to [@qdevstudio](https://t.me/qdevstudio) for their logo for blueprint.

package/dist/build.js

@@ -28,13 +28,17 @@ async function buildOne(contract, ui) {
             }
         }
         const cell = result.code;
+        const rHash = cell.hash();
+        const res = {
+            hash: rHash.toString('hex'),
+            hashBase64: rHash.toString('base64'),
+            hex: cell.toBoc().toString('hex')
+        };
         ui?.clearActionPrompt();
-        ui?.write('\n✅ Compiled successfully! Cell BOC hex result:\n\n');
-        ui?.write(cell.toBoc().toString('hex'));
+        ui?.write('\n✅ Compiled successfully! Cell BOC result:\n\n');
+        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({
-            hex: cell.toBoc().toString('hex'),
-        }));
+        await promises_1.default.writeFile(buildArtifactPath, JSON.stringify(res));
         ui?.write(`\n✅ Wrote compilation artifact to ${path_1.default.relative(process.cwd(), buildArtifactPath)}`);
     }
     catch (e) {

package/dist/cli/Runner.d.ts

@@ -1,5 +1,9 @@
 import arg from 'arg';
 import { UIProvider } from '../ui/UIProvider';
+import { Config } from '../config/Config';
 export declare const argSpec: {};
 export type Args = arg.Result<typeof argSpec>;
-export type Runner = (args: Args, ui: UIProvider) => Promise<void>;
+export type RunnerContext = {
+    config?: Config;
+};
+export type Runner = (args: Args, ui: UIProvider, context: RunnerContext) => Promise<void>;

package/dist/cli/cli.js

@@ -34,8 +34,10 @@ const chalk_1 = __importDefault(require("chalk"));
 const create_1 = require("./create");
 const run_1 = require("./run");
 const build_1 = require("./build");
+const set_1 = require("./set");
 const test_1 = require("./test");
 const verify_1 = require("./verify");
+const convert_1 = require("./convert");
 const help_1 = require("./help");
 const InquirerUIProvider_1 = require("../ui/InquirerUIProvider");
 const Runner_1 = require("./Runner");
@@ -44,9 +46,11 @@ const runners = {
     create: create_1.create,
     run: run_1.run,
     build: build_1.build,
+    set: set_1.set,
     test: test_1.test,
     help: help_1.help,
     verify: verify_1.verify,
+    convert: convert_1.convert,
 };
 async function main() {
     var _a;
@@ -59,12 +63,14 @@ async function main() {
         process.exit(0);
     }
     let effectiveRunners = {};
+    const runnerContext = {};
     try {
         const configModule = await (_a = path_1.default.join(process.cwd(), 'blueprint.config.ts'), Promise.resolve().then(() => __importStar(require(_a))));
         try {
             if ('config' in configModule && typeof configModule.config === 'object') {
                 const config = configModule.config;
-                for (const plugin of config.plugins) {
+                runnerContext.config = config;
+                for (const plugin of config.plugins ?? []) {
                     for (const runner of plugin.runners()) {
                         effectiveRunners[runner.name] = runner.runner;
                         help_1.additionalHelpMessages[runner.name] = runner.help;
@@ -91,7 +97,7 @@ async function main() {
         process.exit(1);
     }
     const ui = new InquirerUIProvider_1.InquirerUIProvider();
-    await runner(args, ui);
+    await runner(args, ui, runnerContext);
     ui.close();
 }
 process.on('SIGINT', () => {

package/dist/cli/convert.d.ts

@@ -0,0 +1,2 @@
+import { Runner } from './Runner';
+export declare const convert: Runner;

package/dist/cli/convert.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convert = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const arg_1 = __importDefault(require("arg"));
+const createNetworkProvider_1 = require("../network/createNetworkProvider");
+const template_1 = require("../template");
+const paths_1 = require("../paths");
+function createWrapperName(old) {
+    return old
+        .split(/[-_]/)
+        .map((x) => x.replace(x[0], x[0].toUpperCase()))
+        .join('');
+}
+function quoteString(str) {
+    const quote = "'";
+    const quoted = str.startsWith(quote) && str.endsWith(quote);
+    return quoted ? str : quote + str + quote;
+}
+function findFile(dir, filename) {
+    const contents = (0, fs_1.readdirSync)(dir);
+    let hasFile = contents.includes(filename);
+    let foundPath = '';
+    if (hasFile) {
+        foundPath = path_1.default.join(dir, filename);
+        if ((0, fs_1.statSync)(foundPath).isFile()) {
+            return foundPath;
+        }
+    }
+    for (let entry of contents) {
+        const entryPath = path_1.default.join(dir, entry);
+        const stat = (0, fs_1.statSync)(entryPath);
+        if (stat.isDirectory()) {
+            foundPath = findFile(entryPath, filename);
+            if (foundPath !== '') {
+                break;
+            }
+        }
+    }
+    return foundPath;
+}
+function parseCompileString(str, src_dir, ui) {
+    // Naive but does the job
+    const tokens = str.split(/\\?\s+/).filter((t) => t != '\\');
+    const outputIdx = tokens.indexOf('-o');
+    if (outputIdx < 0) {
+        throw new Error('No output flag (-o) found in command:' + str);
+    }
+    const outFile = tokens[outputIdx + 1];
+    const outputName = outFile.match(/([A-Za-z0-9\-_\\\/]*)/);
+    if (outputName === null) {
+        throw new Error(`Something went wrong when parsing output from ${outFile}`);
+    }
+    const wrapperName = createWrapperName(path_1.default.basename(outputName[1]));
+    const sourceFiles = tokens.filter((x) => x.match(/\.func|\.fc['"]?$/) !== null).map((t) => t.replace(/['"`]/g, ''));
+    if (sourceFiles.length === 0) {
+        throw new Error(`No source files found in command:${str}`);
+    }
+    for (let i = 0; i < sourceFiles.length; i++) {
+        const testPath = path_1.default.join(src_dir, sourceFiles[i]);
+        if ((0, fs_1.existsSync)(testPath)) {
+            sourceFiles[i] = quoteString(testPath);
+        }
+        else {
+            const foundPath = findFile(src_dir, sourceFiles[i]);
+            if (foundPath === '') {
+                throw new Error(`${sourceFiles[i]} is not found anywhere`);
+            }
+            src_dir = path_1.default.dirname(foundPath);
+            sourceFiles[i] = quoteString(foundPath);
+        }
+    }
+    return {
+        name: wrapperName,
+        targets: sourceFiles.join(','),
+    };
+}
+const convert = async (args, ui) => {
+    const localArgs = (0, arg_1.default)(createNetworkProvider_1.argSpec);
+    let filePath;
+    if (localArgs._.length < 2) {
+        filePath = await ui.input('Please specify path to convert from:');
+    }
+    else {
+        filePath = localArgs._[1];
+    }
+    const content = (0, fs_1.readFileSync)(filePath, { encoding: 'utf-8' });
+    const srcDir = path_1.default.dirname(filePath);
+    const compileStrings = content.replace(/\\[\r?\n]+/g, '').matchAll(/\s?func\s+(.*)\n/g);
+    if (compileStrings === null) {
+        throw new Error(`No func related commands found in ${filePath}`);
+    }
+    const templatePath = path_1.default.join(template_1.TEMPLATES_DIR, 'func', 'legacy', 'wrappers', 'compile.ts.template');
+    const templateContent = (0, fs_1.readFileSync)(templatePath, { encoding: 'utf-8' });
+    if (!(0, fs_1.existsSync)(paths_1.WRAPPERS_DIR)) {
+        ui.write('Creating wrappers directory...');
+        (0, fs_1.mkdirSync)(paths_1.WRAPPERS_DIR);
+    }
+    for (let compileStr of compileStrings) {
+        let parsed;
+        try {
+            parsed = parseCompileString(compileStr[1], srcDir, ui);
+        }
+        catch (e) {
+            ui.write(e.toString());
+            continue;
+        }
+        const resTemplate = (0, template_1.executeTemplate)(templateContent, parsed);
+        let lineIdx = resTemplate.indexOf('\n');
+        const contentIdx = lineIdx + 1;
+        if (resTemplate[lineIdx - 1] === '\r') {
+            lineIdx--;
+        }
+        const wrapperName = resTemplate.substring(0, lineIdx);
+        const fileName = path_1.default.join(paths_1.WRAPPERS_DIR, wrapperName);
+        const content = resTemplate.substring(contentIdx);
+        if ((0, fs_1.existsSync)(fileName)) {
+            ui.write(`File ${wrapperName} already exists!`);
+            const overwrite = await ui.prompt('Do you want to overwrite it?');
+            if (!overwrite) {
+                ui.write(`Skipping ${wrapperName}`);
+                continue;
+            }
+        }
+        (0, fs_1.writeFileSync)(fileName, content, { encoding: 'utf-8' });
+        ui.write(`${wrapperName} wrapper created!`);
+    }
+};
+exports.convert = convert;

package/dist/cli/help.js

@@ -13,9 +13,11 @@ List of available commands:
 - create
 - run
 - build
+- custom
 - help
 - test
-- verify`,
+- verify
+- convert`,
     create: `Usage: blueprint create [contract name] [flags]
 
 Creates a new contract together with supporting files according to a template.
@@ -48,6 +50,9 @@ If contract name is not specified on the command line, the buildable contracts (
 
 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
 
 Just runs \`npm test\`, which by default runs \`jest\`.`,
@@ -61,6 +66,8 @@ Flags:
 --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.`,
 };
 exports.additionalHelpMessages = {};
 const help = async (args, ui) => {

package/dist/cli/run.js

@@ -7,7 +7,7 @@ exports.run = void 0;
 const createNetworkProvider_1 = require("../network/createNetworkProvider");
 const utils_1 = require("../utils");
 const arg_1 = __importDefault(require("arg"));
-const run = async (args, ui) => {
+const run = async (args, ui, context) => {
     const localArgs = (0, arg_1.default)(createNetworkProvider_1.argSpec);
     const { module: mod } = await (0, utils_1.selectFile)(await (0, utils_1.findScripts)(), {
         ui,
@@ -16,7 +16,7 @@ const run = async (args, ui) => {
     if (typeof mod.run !== 'function') {
         throw new Error('Function `run` is missing!');
     }
-    const networkProvider = await (0, createNetworkProvider_1.createNetworkProvider)(ui, localArgs);
+    const networkProvider = await (0, createNetworkProvider_1.createNetworkProvider)(ui, localArgs, context.config);
     await mod.run(networkProvider, localArgs._.slice(2));
 };
 exports.run = run;

package/dist/cli/set.d.ts

@@ -0,0 +1,2 @@
+import { Runner } from './Runner';
+export declare const set: Runner;

package/dist/cli/set.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = void 0;
+const promises_1 = require("fs/promises");
+const node_child_process_1 = require("node:child_process");
+const path_1 = __importDefault(require("path"));
+const getVersions = (pkg, ui) => {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)(`npm view ${pkg} versions --json`, (error, stdout, stderr) => {
+            if (stderr) {
+                ui.write(stderr);
+            }
+            if (stdout) {
+                if (error === null) {
+                    try {
+                        const resJson = JSON.parse(stdout);
+                        if (Array.isArray(resJson)) {
+                            resolve(resJson);
+                        }
+                        else {
+                            reject(new TypeError("Expect json array on stdout, but got:\n" + stdout));
+                        }
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                    return;
+                }
+                else {
+                    ui.write(stdout);
+                }
+            }
+            if (error) {
+                ui.write("Failed to get func-js-bin package versions!");
+                reject(error);
+            }
+        });
+    });
+};
+const install = (cmd, ui) => {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)(cmd, (error, stdout, stderr) => {
+            if (stderr) {
+                ui.write(stderr);
+            }
+            if (stdout) {
+                ui.write(stdout);
+            }
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+const set = async (args, ui) => {
+    if (args._.length < 2) {
+        throw new Error('Please pass a key');
+    }
+    switch (args._[1]) {
+        case 'func': {
+            const pkg = '@ton-community/func-js-bin';
+            const funcVersions = await getVersions(pkg, ui);
+            let version = args._.length > 2 ? args._[2] : '';
+            if (!funcVersions.includes(version)) {
+                version = await ui.choose('Choose FunC version', funcVersions, (s) => s);
+            }
+            const packagePath = path_1.default.join(process.cwd(), 'package.json');
+            const packageContents = (await (0, promises_1.readFile)(packagePath)).toString('utf-8');
+            const parsedPackage = JSON.parse(packageContents);
+            const packageManager = await ui.choose('Choose your package manager', ['npm', 'yarn', 'pnpm', 'other'], (s) => s);
+            if (packageManager === 'other') {
+                ui.write(`Please find out how to override @ton-community/func-js-bin version to ${version} using your package manager, do that, and then install the packages`);
+                return;
+            }
+            const overrideKey = packageManager === 'yarn' ? 'resolutions' : 'overrides';
+            parsedPackage[overrideKey] = {
+                ...parsedPackage[overrideKey],
+                [pkg]: version,
+            };
+            ui.write('Updating package.json...');
+            await (0, promises_1.writeFile)(packagePath, JSON.stringify(parsedPackage, null, 4));
+            const installCmd = packageManager === 'yarn' ? 'yarn' : `${packageManager} i`;
+            try {
+                ui.write('Installing dependencies...');
+                await install(installCmd, ui);
+            }
+            catch (e) {
+                ui.write('Failed to install dependencies, rolling back package.json');
+                await (0, promises_1.writeFile)(packagePath, packageContents);
+                throw e;
+            }
+            break;
+        }
+        default: {
+            throw new Error('Unknown key: ' + args._[1]);
+        }
+    }
+};
+exports.set = set;

package/dist/cli/verify.js

@@ -9,6 +9,7 @@ const compile_1 = require("../compile/compile");
 const path_1 = __importDefault(require("path"));
 const createNetworkProvider_1 = require("../network/createNetworkProvider");
 const build_1 = require("./build");
+const utils_1 = require("../utils");
 const arg_1 = __importDefault(require("arg"));
 const backends = {
     mainnet: {
@@ -57,10 +58,62 @@ class VerifierRegistry {
         });
     }
 }
-const verify = async (args, ui) => {
+async function lookupCodeHash(hash, ui, retryCount = 5) {
+    let queryResponse;
+    let foundAddr;
+    let done = false;
+    const graphqlUrl = 'https://dton.io/graphql/';
+    const query = `{
+        account_states(page:0, page_size:1, account_state_state_init_code_hash: "${hash.toString('hex').toUpperCase()}")
+        {
+            address
+            workchain
+        }
+    }`;
+    do {
+        try {
+            ui.write('Checking if such a contract is already deployed...');
+            const resp = await fetch(graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({ query }),
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (resp.ok) {
+                queryResponse = await resp.json();
+                const states = queryResponse.data.account_states;
+                if (states.length > 0) {
+                    const state = states[0];
+                    foundAddr = core_1.Address.parseRaw(`${state.workchain}:${state.address}`).toString();
+                }
+                else {
+                    ui.write('No such contract was found!');
+                }
+                done = true;
+            }
+            else {
+                retryCount--;
+            }
+            // Meh
+        }
+        catch (e) {
+            retryCount--;
+            if (e.cause) {
+                if (e.cause.code == 'ETIMEDOUT') {
+                    ui.write('API timed out, waiting...');
+                    await (0, utils_1.sleep)(5000);
+                }
+            }
+            else {
+                ui.write(e);
+            }
+        }
+    } while (!done && retryCount > 0);
+    return foundAddr;
+}
+const verify = async (args, ui, context) => {
     const localArgs = (0, arg_1.default)(createNetworkProvider_1.argSpec);
     const sel = await (0, build_1.selectCompile)(ui, localArgs);
-    const networkProvider = await (0, createNetworkProvider_1.createNetworkProvider)(ui, localArgs, false);
+    const networkProvider = await (0, createNetworkProvider_1.createNetworkProvider)(ui, localArgs, context.config, false);
     const sender = networkProvider.sender();
     const senderAddress = sender.address;
     if (senderAddress === undefined) {
@@ -70,8 +123,27 @@ const verify = async (args, ui) => {
     if (network === 'custom') {
         throw new Error('Cannot use custom network');
     }
-    const addr = await ui.input('Deployed contract address');
     const result = await (0, compile_1.doCompile)(sel.name);
+    const resHash = result.code.hash();
+    ui.write(`Compiled code hash hex:${resHash.toString('hex')}`);
+    ui.write('We can look up the address with such code hash in the blockchain automatically');
+    const passManually = await ui.prompt('Do you want to specify the address manually?');
+    let addr;
+    if (passManually) {
+        addr = (await ui.inputAddress('Deployed contract address')).toString();
+    }
+    else {
+        const alreadyDeployed = await lookupCodeHash(resHash, ui);
+        if (alreadyDeployed) {
+            ui.write(`Contract is already deployed at: ${alreadyDeployed}\nUsing that address.`);
+            ui.write(`https://tonscan.org/address/${alreadyDeployed}`);
+            addr = alreadyDeployed;
+        }
+        else {
+            ui.write("Please enter the contract's address manually");
+            addr = (await ui.inputAddress('Deployed contract address')).toString();
+        }
+    }
     let src;
     const fd = new FormData();
     if (result.lang === 'func') {
@@ -149,23 +221,26 @@ const verify = async (args, ui) => {
         body: fd,
     });
     if (sourceResponse.status !== 200) {
-        throw new Error('Could not compile on backend:\n' + (await sourceResponse.text()));
+        throw new Error('Could not compile on backend:\n' + (await sourceResponse.json()));
     }
     const sourceResult = await sourceResponse.json();
     if (sourceResult.compileResult.result !== 'similar') {
-        throw new Error('The code is not similar');
+        throw new Error(sourceResult.compileResult.error);
     }
     let msgCell = sourceResult.msgCell;
     let acquiredSigs = 1;
     while (acquiredSigs < verifier.quorum) {
-        const signResponse = await fetch(removeRandom(remainingBackends) + '/sign', {
+        const curBackend = removeRandom(remainingBackends);
+        ui.write(`Using backend: ${curBackend}`);
+        const signResponse = await fetch(curBackend + '/sign', {
             method: 'POST',
             body: JSON.stringify({
                 messageCell: msgCell,
             }),
+            headers: { 'Content-Type': 'application/json' },
         });
         if (signResponse.status !== 200) {
-            throw new Error('Could not compile on backend:\n' + (await signResponse.text()));
+            throw new Error('Could not sign on backend:\n' + (await signResponse.text()));
         }
         const signResult = await signResponse.json();
         msgCell = signResult.msgCell;
@@ -177,5 +252,6 @@ const verify = async (args, ui) => {
         value: (0, core_1.toNano)('0.5'),
         body: c,
     });
+    ui.write(`Contract successfully verified at https://verifier.ton.org/${addr}`);
 };
 exports.verify = verify;

package/dist/compile/CompilerConfig.d.ts

@@ -1,9 +1,12 @@
 import { SourceResolver, SourcesMap, SourcesArray } from '@ton-community/func-js';
 import { Cell } from '@ton/core';
 import { ConfigProject } from '@tact-lang/compiler';
+export type HookParams = {
+    userData?: any;
+};
 export type CommonCompilerConfig = {
-    preCompileHook?: () => Promise<void>;
-    postCompileHook?: (code: Cell) => Promise<void>;
+    preCompileHook?: (params: HookParams) => Promise<void>;
+    postCompileHook?: (code: Cell, params: HookParams) => Promise<void>;
 };
 export type TactCompilerConfig = {
     lang: 'tact';

package/dist/compile/compile.d.ts

@@ -14,5 +14,8 @@ export type TactCompileResult = {
     code: Cell;
 };
 export type CompileResult = TactCompileResult | FuncCompileResult;
-export declare function doCompile(name: string): Promise<CompileResult>;
-export declare function compile(name: string): Promise<Cell>;
+export declare function doCompile(name: string, opts?: CompileOpts): Promise<CompileResult>;
+export type CompileOpts = {
+    hookUserData?: any;
+};
+export declare function compile(name: string, opts?: CompileOpts): Promise<Cell>;

package/dist/compile/compile.js

@@ -106,20 +106,24 @@ async function doCompileInner(name, config) {
         optLevel: config.optLevel,
     });
 }
-async function doCompile(name) {
+async function doCompile(name, opts) {
     const config = await getCompilerConfigForContract(name);
     if (config.preCompileHook !== undefined) {
-        await config.preCompileHook();
+        await config.preCompileHook({
+            userData: opts?.hookUserData,
+        });
     }
     const res = await doCompileInner(name, config);
     if (config.postCompileHook !== undefined) {
-        await config.postCompileHook(res.code);
+        await config.postCompileHook(res.code, {
+            userData: opts?.hookUserData,
+        });
     }
     return res;
 }
 exports.doCompile = doCompile;
-async function compile(name) {
-    const result = await doCompile(name);
+async function compile(name, opts) {
+    const result = await doCompile(name, opts);
     return result.code;
 }
 exports.compile = compile;

package/dist/config/Config.d.ts

@@ -1,4 +1,6 @@
+import { CustomNetwork } from './CustomNetwork';
 import { Plugin } from './Plugin';
 export interface Config {
-    plugins: Plugin[];
+    plugins?: Plugin[];
+    network?: 'mainnet' | 'testnet' | CustomNetwork;
 }

package/dist/config/CustomNetwork.d.ts

@@ -0,0 +1,6 @@
+export type CustomNetwork = {
+    endpoint: string;
+    version?: 'v2' | 'v4';
+    key?: string;
+    type?: 'mainnet' | 'testnet' | 'custom';
+};

package/dist/config/CustomNetwork.js

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

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 export { tonDeepLink, sleep } from './utils';
 export { NetworkProvider } from './network/NetworkProvider';
 export { createNetworkProvider } from './network/createNetworkProvider';
-export { compile } from './compile/compile';
-export { CompilerConfig } from './compile/CompilerConfig';
+export { compile, CompileOpts } from './compile/compile';
+export { CompilerConfig, HookParams } from './compile/CompilerConfig';
 export { UIProvider } from './ui/UIProvider';
 export { Config } from './config/Config';
-export { Args, Runner } from './cli/Runner';
+export { Args, Runner, RunnerContext } from './cli/Runner';
 export { PluginRunner, Plugin } from './config/Plugin';
+export { CustomNetwork } from './config/CustomNetwork';
 export { buildOne, buildAll } from './build';

package/dist/network/createNetworkProvider.d.ts

@@ -1,6 +1,7 @@
 import arg from 'arg';
 import { UIProvider } from '../ui/UIProvider';
 import { NetworkProvider } from './NetworkProvider';
+import { Config } from '../config/Config';
 export declare const argSpec: {
     '--mainnet': BooleanConstructor;
     '--testnet': BooleanConstructor;
@@ -18,4 +19,4 @@ export declare const argSpec: {
     '--dton': BooleanConstructor;
 };
 export type Args = arg.Result<typeof argSpec>;
-export declare function createNetworkProvider(ui: UIProvider, args: Args, allowCustom?: boolean): Promise<NetworkProvider>;
+export declare function createNetworkProvider(ui: UIProvider, args: Args, config?: Config, allowCustom?: boolean): Promise<NetworkProvider>;

package/dist/network/createNetworkProvider.js

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _SendProviderSender_provider, _WrappedContractProvider_address, _WrappedContractProvider_provider, _WrappedContractProvider_init, _NetworkProviderImpl_tc, _NetworkProviderImpl_sender, _NetworkProviderImpl_network, _NetworkProviderImpl_explorer, _NetworkProviderImpl_ui;
+var _SendProviderSender_provider, _WrappedContractProvider_address, _WrappedContractProvider_provider, _WrappedContractProvider_init, _WrappedContractProvider_factory, _NetworkProviderImpl_tc, _NetworkProviderImpl_sender, _NetworkProviderImpl_network, _NetworkProviderImpl_explorer, _NetworkProviderImpl_ui;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNetworkProvider = exports.argSpec = void 0;
 const utils_1 = require("../utils");
@@ -63,13 +63,15 @@ class SendProviderSender {
 }
 _SendProviderSender_provider = new WeakMap();
 class WrappedContractProvider {
-    constructor(address, provider, init) {
+    constructor(address, factory, init) {
         _WrappedContractProvider_address.set(this, void 0);
         _WrappedContractProvider_provider.set(this, void 0);
         _WrappedContractProvider_init.set(this, void 0);
+        _WrappedContractProvider_factory.set(this, void 0);
         __classPrivateFieldSet(this, _WrappedContractProvider_address, address, "f");
-        __classPrivateFieldSet(this, _WrappedContractProvider_provider, provider, "f");
+        __classPrivateFieldSet(this, _WrappedContractProvider_provider, factory({ address, init }), "f");
         __classPrivateFieldSet(this, _WrappedContractProvider_init, init, "f");
+        __classPrivateFieldSet(this, _WrappedContractProvider_factory, factory, "f");
     }
     async getState() {
         return await __classPrivateFieldGet(this, _WrappedContractProvider_provider, "f").getState();
@@ -91,8 +93,14 @@ class WrappedContractProvider {
             body: typeof args.body === 'string' ? (0, core_1.comment)(args.body) : args.body,
         });
     }
+    open(contract) {
+        return (0, core_1.openContract)(contract, (params) => new WrappedContractProvider(params.address, __classPrivateFieldGet(this, _WrappedContractProvider_factory, "f"), params.init));
+    }
+    getTransactions(address, lt, hash, limit) {
+        return __classPrivateFieldGet(this, _WrappedContractProvider_provider, "f").getTransactions(address, lt, hash, limit);
+    }
 }
-_WrappedContractProvider_address = new WeakMap(), _WrappedContractProvider_provider = new WeakMap(), _WrappedContractProvider_init = new WeakMap();
+_WrappedContractProvider_address = new WeakMap(), _WrappedContractProvider_provider = new WeakMap(), _WrappedContractProvider_init = new WeakMap(), _WrappedContractProvider_factory = new WeakMap();
 class NetworkProviderImpl {
     constructor(tc, sender, network, explorer, ui) {
         _NetworkProviderImpl_tc.set(this, void 0);
@@ -119,12 +127,8 @@ class NetworkProviderImpl {
         return __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f");
     }
     provider(address, init) {
-        if (__classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f") instanceof ton_1.TonClient4) {
-            return new WrappedContractProvider(address, __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").provider(address, init ? { code: init.code ?? new core_1.Cell(), data: init.data ?? new core_1.Cell() } : undefined), init);
-        }
-        else {
-            return new WrappedContractProvider(address, __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").provider(address, { code: init?.code ?? new core_1.Cell(), data: init?.data ?? new core_1.Cell() }), init);
-        }
+        const factory = (params) => __classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f").provider(params.address, params.init);
+        return new WrappedContractProvider(address, factory, init);
     }
     async isContractDeployed(address) {
         if (__classPrivateFieldGet(this, _NetworkProviderImpl_tc, "f") instanceof ton_1.TonClient4) {
@@ -176,7 +180,7 @@ class NetworkProviderImpl {
         await this.waitForDeploy(contract.address, waitAttempts);
     }
     open(contract) {
-        return (0, core_1.openContract)(contract, (params) => this.provider(params.address, params.init ?? undefined));
+        return (0, core_1.openContract)(contract, (params) => this.provider(params.address, params.init ?? null));
     }
     ui() {
         return __classPrivateFieldGet(this, _NetworkProviderImpl_ui, "f");
@@ -198,9 +202,10 @@ async function createMnemonicProvider(client, ui) {
     });
 }
 class NetworkProviderBuilder {
-    constructor(args, ui, allowCustom = true) {
+    constructor(args, ui, config, allowCustom = true) {
         this.args = args;
         this.ui = ui;
+        this.config = config;
         this.allowCustom = allowCustom;
     }
     async chooseNetwork() {
@@ -209,14 +214,18 @@ class NetworkProviderBuilder {
             testnet: this.args['--testnet'],
             custom: this.args['--custom'] !== undefined,
         });
-        if (!network) {
-            network = await this.ui.choose('Which network do you want to use?', ['mainnet', 'testnet', 'custom'], (c) => c);
-            if (network === 'custom') {
-                const defaultCustomEndpoint = 'http://localhost:8081/';
-                this.args['--custom'] = (await this.ui.input(`Provide a custom API v2 endpoint (default is ${defaultCustomEndpoint})`)).trim();
-                if (this.args['--custom'] === '')
-                    this.args['--custom'] = defaultCustomEndpoint;
-            }
+        if (network !== undefined) {
+            return network;
+        }
+        if (this.config?.network !== undefined) {
+            return typeof this.config.network === 'string' ? this.config.network : 'custom';
+        }
+        network = await this.ui.choose('Which network do you want to use?', ['mainnet', 'testnet', 'custom'], (c) => c);
+        if (network === 'custom') {
+            const defaultCustomEndpoint = 'http://localhost:8081/';
+            this.args['--custom'] = (await this.ui.input(`Provide a custom API v2 endpoint (default is ${defaultCustomEndpoint})`)).trim();
+            if (this.args['--custom'] === '')
+                this.args['--custom'] = defaultCustomEndpoint;
         }
         return network;
     }
@@ -290,26 +299,50 @@ class NetworkProviderBuilder {
         }
         let tc;
         if (network === 'custom') {
-            const endpoint = this.args['--custom'];
-            if (this.args['--custom-version'] === undefined || this.args['--custom-version'].toLowerCase() === 'v2') {
+            let configNetwork = undefined;
+            if (this.config?.network !== undefined && typeof this.config.network !== 'string') {
+                configNetwork = this.config.network;
+            }
+            if (this.args['--custom'] !== undefined) {
+                const inputVer = this.args['--custom-version'];
+                let version = undefined;
+                if (inputVer !== undefined) {
+                    version = inputVer.toLowerCase(); // checks come later
+                }
+                const inputType = this.args['--custom-type'];
+                let type = undefined;
+                if (inputType !== undefined) {
+                    type = inputType; // checks come later
+                }
+                configNetwork = {
+                    endpoint: this.args['--custom'],
+                    version,
+                    key: this.args['--custom-key'],
+                    type,
+                };
+            }
+            if (configNetwork === undefined) {
+                throw new Error('Custom network is (somehow) undefined');
+            }
+            if (configNetwork.version === undefined || configNetwork.version === 'v2') {
                 tc = new ton_1.TonClient({
-                    endpoint: endpoint + 'jsonRPC',
-                    apiKey: this.args['--custom-key'],
+                    endpoint: configNetwork.endpoint,
+                    apiKey: configNetwork.key,
                 });
             }
-            else if (this.args['--custom-version'].toLowerCase() === 'v4') {
-                if (this.args['--custom-key'] !== undefined) {
+            else if (configNetwork.version === 'v4') {
+                if (configNetwork.key !== undefined) {
                     throw new Error('Cannot use a custom API key with a v4 API');
                 }
                 tc = new ton_1.TonClient4({
-                    endpoint,
+                    endpoint: configNetwork.endpoint,
                 });
             }
             else {
-                throw new Error('Unknown API version: ' + this.args['--custom-version']);
+                throw new Error('Unknown API version: ' + configNetwork.version);
             }
-            if (this.args['--custom-type'] !== undefined) {
-                const ct = this.args['--custom-type'].toLowerCase();
+            if (configNetwork.type !== undefined) {
+                const ct = configNetwork.type.toLowerCase();
                 if (!['mainnet', 'testnet', 'custom'].includes(ct)) {
                     throw new Error('Unknown network type: ' + ct);
                 }
@@ -339,7 +372,7 @@ class NetworkProviderBuilder {
         return new NetworkProviderImpl(tc, sender, network, explorer, this.ui);
     }
 }
-async function createNetworkProvider(ui, args, allowCustom = true) {
-    return await new NetworkProviderBuilder(args, ui, allowCustom).build();
+async function createNetworkProvider(ui, args, config, allowCustom = true) {
+    return await new NetworkProviderBuilder(args, ui, config, allowCustom).build();
 }
 exports.createNetworkProvider = createNetworkProvider;

package/dist/templates/func/legacy/wrappers/compile.ts.template

@@ -0,0 +1,7 @@
+{{name}}.compile.ts
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    lang: 'func',
+    targets: [{{targets}}],
+};

package/dist/ui/InquirerUIProvider.d.ts

@@ -1,9 +1,11 @@
 import { UIProvider } from '../ui/UIProvider';
+import { Address } from '@ton/core';
 export declare class InquirerUIProvider implements UIProvider {
     #private;
     constructor();
     write(message: string): void;
     prompt(message: string): Promise<boolean>;
+    inputAddress(message: string, fallback?: Address): Promise<Address>;
     input(message: string): Promise<string>;
     choose<T>(message: string, choices: T[], display: (v: T) => string): Promise<T>;
     setActionPrompt(message: string): void;

package/dist/ui/InquirerUIProvider.js

@@ -17,6 +17,7 @@ var _InquirerUIProvider_bottomBar;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InquirerUIProvider = void 0;
 const inquirer_1 = __importDefault(require("inquirer"));
+const core_1 = require("@ton/core");
 class DestroyableBottomBar extends inquirer_1.default.ui.BottomBar {
     destroy() {
         this.close();
@@ -38,6 +39,18 @@ class InquirerUIProvider {
         });
         return prompt;
     }
+    async inputAddress(message, fallback) {
+        const prompt = message + (fallback === undefined ? '' : ` (default: ${fallback})`);
+        while (true) {
+            const addr = (await this.input(prompt)).trim();
+            try {
+                return addr === '' && fallback !== undefined ? fallback : core_1.Address.parse(addr);
+            }
+            catch (e) {
+                this.write(addr + ' is not valid!\n');
+            }
+        }
+    }
     async input(message) {
         const { val } = await inquirer_1.default.prompt({
             name: 'val',

package/dist/ui/UIProvider.d.ts

@@ -1,6 +1,8 @@
+import { Address } from '@ton/core';
 export interface UIProvider {
     write(message: string): void;
     prompt(message: string): Promise<boolean>;
+    inputAddress(message: string, fallback?: Address): Promise<Address>;
     input(message: string): Promise<string>;
     choose<T>(message: string, choices: T[], display: (v: T) => string): Promise<T>;
     setActionPrompt(message: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/blueprint",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Framework for development of TON smart contracts",
   "main": "dist/index.js",
   "bin": "./dist/cli/cli.js",
@@ -19,9 +19,9 @@
     "format": "prettier --write src"
   },
   "devDependencies": {
-    "@ton/core": "^0.49.2",
+    "@ton/core": "^0.56.0",
     "@ton/crypto": "^3.2.0",
-    "@ton/ton": "^13.5.1",
+    "@ton/ton": "^13.11.0",
     "@types/inquirer": "^8.2.6",
     "@types/node": "^20.2.5",
     "@types/qrcode-terminal": "^0.12.0",
@@ -29,9 +29,9 @@
     "typescript": "^4.9.5"
   },
   "peerDependencies": {
-    "@ton/core": ">=0.49.2",
+    "@ton/core": ">=0.56.0",
     "@ton/crypto": ">=3.2.0",
-    "@ton/ton": ">=13.4.1"
+    "@ton/ton": ">=13.11.0"
   },
   "dependencies": {
     "@orbs-network/ton-access": "^2.3.3",