@ton/blueprint 0.10.0

package/CHANGELOG.md

@@ -0,0 +1,146 @@
+# Changelog
+
+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.10.0] - 2023-06-06
+
+### Added
+
+- Added two optional fields to the `CompilerConfig`: `preCompileHook?: () => Promise<void>` and `postCompileHook?: (code: Cell) => Promise<void>`. The former one gets called before any compilation of the respective contract happens, the latter one - after any compilation with the compiled code cell (they are called both during the `build` command and when calling the `compile` function for the respective contracts)
+
+### Changed
+
+- Changed the `run` command to only show `.ts` scripts
+
+## [0.9.0] - 2023-04-21
+
+### Changed
+
+- Updated dependencies, of note: func-js to use func 0.4.3, TACT to 1.1.1
+
+## [0.8.0] - 2023-04-07
+
+### Changed
+
+- Changed the `help` command to contain significantly more detailed help for every command
+- Added the `success: true` requirement to every template test
+- Updated dependencies
+
+## [0.7.0] - 2023-04-03
+
+This release contains a breaking change.
+
+### Changed
+
+- Changed the return type of `networkProvider.api()` and the type used internally in `NetworkProvider` from `TonClient` to `TonClient4`. This is a breaking change
+- Updated dependencies
+
+## [0.6.1] - 2023-03-27
+
+### Changed
+
+- Changed `UIProvider.prompt` return type from `Promise<void>` to `Promise<boolean>`
+
+## [0.6.0] - 2023-03-21
+
+### Added
+
+- Added support for [TACT](https://github.com/tact-lang/tact), including TACT smart contract templates
+- Added `--all` option for `build` command
+
+### Changed
+
+- Updated dependencies
+
+## [0.5.0] - 2023-03-13
+
+### Changed
+
+- `SendProvider` now returns `Promise<any>` instead of `Promise<void>` from `sendTransaction`. This allows providers using TON Connect and TonHub to return the results from their backends to the end user
+
+## [0.4.1] - 2023-03-02
+
+### Changed
+
+- Changed ton peer dependency version to `>=13.4.1`
+
+## [0.4.0] - 2023-03-01
+
+This release contains a breaking change.
+
+### Changed
+
+- Changed ton-core peer dependency version to `>=0.48.0`. This is a breaking change
+
+### Added
+
+- Added a new mnemonic deployer. Environment variables `WALLET_MNEMONIC` and `WALLET_VERSION` must be set, or a .env file with them must be present in order for it to be usable. Tonkeeper's v4R2 wallet corresponds to v4 version in blueprint
+- Added the ability to choose the explorer for the deployed contracts. Pass one of the CLI flags `--tonscan`, `--tonapi`, `--toncx`, `--dton` to choose. Tonscan is the default
+- Added ton-crypto peer dependency of version `>=3.2.0`
+
+### Fixed
+
+- Fixed TonHub deployer's `Sent transaction` message
+- Fixed `SendMode.PAY_GAS_SEPARATLY` (missing E) typo in accordance with ton-core update
+- Fixed a crash when using `blueprint run` with flags but no file name
+
+## [0.3.0] - 2023-02-27
+
+### Added
+
+- Added an increment counter script for the counter template
+- Added `isContractDeployed(address)` method to `NetworkProvider`
+- Added `waitForDeploy(address, attempts?, sleepDuration?)` method to `NetworkProvider`
+
+### Fixed
+
+- Fixed exit code 1 on Windows even in case of successful execution
+- Fixed paths to `.fc` files in `.compile.ts` files on Windows
+- Fixed `TonConnectProvider` output
+
+### Changed
+
+- Converted ```Deployer sender does not support `bounce` ``` error into a warning
+- Added an optional `init?: { code?: Cell; data?: Cell }` argument to `provider` method on `NetworkProvider`
+- `createNetworkProvider` now requires a `UIProvider`
+- Removed excessive comments from counter template contract
+- Changed deploy script templates to use `sendDeploy` and `waitForDeploy` instead of `deploy`
+- Refactored test templates to create `Blockchain` and deploy contract in `beforeEach`
+- Disabled file choice menu when there is only 1 file
+
+### Deprecated
+
+- Deprecated `deploy` method on `NetworkProvider`. Users are advised to use self-implemented `sendDeploy` (or similar) methods on their `Contract` instances together with `isContractDeployed` or `waitForDeploy` on `NetworkProvider`
+
+## [0.2.0] - 2023-02-09
+
+### Added
+
+- Added `blueprint test` command
+- Added a pretty help message
+- Added a hint to indicate that contract names must be PascalCase, and a restriction that contract names must start with a capital letter
+- Added a better error message on an unknown command
+
+### Fixed
+
+- Fixed counter templates
+- Fixed an issue where using `networkProvider.provider` and `networkProvider.open` would lead to `Deployer sender does not support "bounce"` message when trying to send internal messages
+
+### Changed
+
+- `networkProvider.provider` and `networkProvider.open` now wrap `TonClient`'s `ContractProvider` instead of directly using it for better control over passed arguments
+- Removed unnecessary `await` keywords from all templates
+
+## [0.1.0] - 2023-02-03
+
+### Added
+
+- Added fully interactive and fully non-interactive modes for the `create` command
+- Added `input(message)` method to `UIProvider` and `InquirerUIProvider`
+
+### Fixed
+
+- File selection (compilation files in `build` and scripts in `run`) now accepts CLI argument hints in any case

package/README.md

@@ -0,0 +1,114 @@
+<img src="https://raw.githubusercontent.com/ton-org/blueprint/main/logo.svg" width=400 >
+
+# Blueprint
+
+A development environment for TON blockchain for writing, testing, and deploying smart contracts.
+
+### Quick start 🚀
+
+Run the following in terminal to create a new project and follow the on-screen instructions:
+
+```console
+npm create ton@latest
+```
+
+&nbsp;
+
+### Core features 🔥
+
+* Create a development environment from template in one click - `npm create ton@latest`
+* Streamlined workflow for building, testing and deploying smart contracts
+* Dead simple deployment to mainnet/testnet using your favorite wallet (eg. Tonkeeper)
+* Blazing fast testing of multiple smart contracts in an isolated blockchain running in-process
+
+### Tech stack
+
+1. Compiling FunC with https://github.com/ton-community/func-js (no CLI)
+2. Testing smart contracts with https://github.com/ton-org/sandbox
+3. Deploying smart contracts with [TON Connect 2](https://github.com/ton-connect), [Tonhub wallet](https://tonhub.com/) or a `ton://` deeplink
+
+### Requirements
+
+* [Node.js](https://nodejs.org) with a recent version like v18, verify version with `node -v`
+* IDE with TypeScript and FunC support like [Visual Studio Code](https://code.visualstudio.com/) with the [FunC plugin](https://marketplace.visualstudio.com/items?itemName=tonwhales.func-vscode)
+
+&nbsp;
+
+## Create a new project
+
+1. Run and follow the on-screen instructions: &nbsp;  `npm create ton@latest` &nbsp; or &nbsp; `npx create-ton@latest`
+2. (Optional) Then from the project directory: &nbsp; `npm install` &nbsp; or &nbsp; `yarn install`
+
+### Directory structure
+
+* `contracts/` - Source code in [FunC](https://ton.org/docs/develop/func/overview) for all smart contracts and their imports
+* `wrappers/` - TypeScript interface classes for all contracts (implementing `Contract` from [ton-core](https://www.npmjs.com/package/ton-core))
+  * include message [de]serialization primitives, getter wrappers and compilation functions
+  * used by the test suite and client code to interact with the contracts from TypeScript
+* `tests/` - TypeScript test suite for all contracts (relying on [Sandbox](https://github.com/ton-org/sandbox) for in-process tests)
+* `scripts/` - Deployment scripts to mainnet/testnet and other scripts interacting with live contracts
+* `build/` - Compilation artifacts created here after running a build command
+
+### Build one of the contracts
+
+1. You need a compilation script in `wrappers/<CONTRACT>.compile.ts` - [example](/example/wrappers/Counter.compile.ts)
+2. Run interactive: &nbsp;&nbsp; `npx blueprint build` &nbsp; or &nbsp; `yarn blueprint build`
+3. Non-interactive: &nbsp; `npx/yarn blueprint build <CONTRACT>`
+   * Example: `yarn blueprint build counter`
+4. Build results are generated in `build/<CONTRACT>.compiled.json`
+
+### Run the test suite
+
+1. Run in terminal: &nbsp; `npx blueprint test` &nbsp; or &nbsp; `yarn blueprint test`
+2. Alternative method: &nbsp; `npm test` &nbsp; or &nbsp; `yarn test`
+
+### Deploy one of the contracts
+
+1. You need a deploy script in `scripts/deploy<CONTRACT>.ts` - [example](/example/scripts/deployCounter.ts)
+2. Run interactive: &nbsp;&nbsp; `npx blueprint run` &nbsp; or &nbsp; `yarn blueprint run`
+3. Non-interactive: &nbsp; `npx/yarn blueprint run <CONTRACT> --<NETWORK> --<DEPLOY_METHOD>`
+   * Example: `yarn blueprint run deployCounter --mainnet --tonconnect`
+
+### Help and additional commands
+
+Run in terminal: &nbsp; `npx blueprint help` &nbsp; or &nbsp; `yarn blueprint help`
+
+&nbsp;
+
+## Develop a new contract
+
+1. Make sure you have a project to host the contract
+2. Run interactive: &nbsp;&nbsp; `npx blueprint create` &nbsp; or &nbsp; `yarn blueprint create`
+3. Non-interactive: &nbsp; `npx/yarn blueprint create <CONTRACT> --type <TYPE>` (type can be `func-empty`, `func-counter`, `tact-empty`, `tact-counter`)
+   * Example: `yarn blueprint create MyNewContract --type func-empty`
+
+### Contract code
+
+1. Implement the standalone FunC root contract in `contracts/<CONTRACT>.fc`
+2. Implement shared FunC imports (if breaking code to multiple files) in `contracts/imports/*.fc`
+3. Implement wrapper TypeScript class in `wrappers/<CONTRACT>.ts` to encode messages and decode getters
+
+### Test suite
+
+1. Implement TypeScript tests in `tests/<CONTRACT>.spec.ts`
+2. Rely on the wrapper TypeScript class from `wrappers/<CONTRACT>.ts` to interact with the contract
+
+### Compilation and deployment
+
+1. Implement a compilation script in `wrappers/<CONTRACT>.compile.ts`
+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
+
+&nbsp;
+
+## Contributors
+
+Special thanks to [@qdevstudio](https://t.me/qdevstudio) for their logo for blueprint.
+
+## License
+
+MIT
+
+## Donations
+
+TON - `EQAQR1d1Q4NaE5EefwUMdrr1QvXg-8mDB0XI2-fwDBD0nYxC`

package/dist/cli/build.d.ts

@@ -0,0 +1,4 @@
+import { Runner } from './cli';
+import { UIProvider } from '../ui/UIProvider';
+export declare function buildOne(contract: string, ui: UIProvider): Promise<void>;
+export declare const build: Runner;

package/dist/cli/build.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = exports.buildOne = void 0;
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const utils_1 = require("../utils");
+const promises_1 = __importDefault(require("fs/promises"));
+const compile_1 = require("../compile/compile");
+const arg_1 = __importDefault(require("arg"));
+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`);
+    try {
+        await promises_1.default.unlink(buildArtifactPath);
+    }
+    catch (e) { }
+    ui.setActionPrompt('⏳ Compiling...');
+    try {
+        const result = await (0, compile_1.doCompile)(contract);
+        if (result.lang === 'tact') {
+            for (const [k, v] of result.fs) {
+                await promises_1.default.mkdir(path_1.default.dirname(k), {
+                    recursive: true,
+                });
+                await promises_1.default.writeFile(k, v);
+            }
+        }
+        const cell = result.code;
+        ui.clearActionPrompt();
+        ui.write('\n✅ Compiled successfully! Cell BOC hex result:\n\n');
+        ui.write(cell.toBoc().toString('hex'));
+        await promises_1.default.mkdir(paths_1.BUILD_DIR, { recursive: true });
+        await promises_1.default.writeFile(buildArtifactPath, JSON.stringify({
+            hex: cell.toBoc().toString('hex'),
+        }));
+        ui.write(`\n✅ Wrote compilation artifact to ${path_1.default.relative(process.cwd(), buildArtifactPath)}`);
+    }
+    catch (e) {
+        ui.clearActionPrompt();
+        ui.write(e.toString());
+        process.exit(1);
+    }
+}
+exports.buildOne = buildOne;
+const build = async (args, ui) => {
+    require('ts-node/register');
+    const localArgs = (0, arg_1.default)({
+        '--all': Boolean,
+    });
+    const files = await (0, utils_1.findCompiles)();
+    if (localArgs['--all']) {
+        for (const file of files) {
+            await buildOne(file.name, ui);
+        }
+    }
+    else {
+        const sel = await (0, utils_1.selectFile)(files, {
+            ui,
+            hint: args._.length > 1 && args._[1].length > 0 ? args._[1] : undefined,
+            import: false,
+        });
+        await buildOne(sel.name, ui);
+    }
+};
+exports.build = build;

package/dist/cli/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import arg from 'arg';
+import { UIProvider } from '../ui/UIProvider';
+declare const argSpec: {};
+export type Args = arg.Result<typeof argSpec>;
+export type Runner = (args: Args, ui: UIProvider) => Promise<void>;
+export {};

package/dist/cli/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 });
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const arg_1 = __importDefault(require("arg"));
+const chalk_1 = __importDefault(require("chalk"));
+const create_1 = require("./create");
+const run_1 = require("./run");
+const build_1 = require("./build");
+const test_1 = require("./test");
+const help_1 = require("./help");
+const InquirerUIProvider_1 = require("../ui/InquirerUIProvider");
+const argSpec = {};
+const runners = {
+    create: create_1.create,
+    run: run_1.run,
+    build: build_1.build,
+    test: test_1.test,
+    help: help_1.help,
+};
+async function main() {
+    const args = (0, arg_1.default)(argSpec, {
+        permissive: true,
+    });
+    if (args._.length === 0) {
+        showHelp();
+        process.exit(0);
+    }
+    const runner = runners[args._[0]];
+    if (!runner) {
+        console.log(chalk_1.default.redBright(` Error: command not found.`) + ` Run 'blueprint help' to see available commands\n`);
+        process.exit(1);
+    }
+    const ui = new InquirerUIProvider_1.InquirerUIProvider();
+    await runner({
+        ...args,
+        _: args._.filter((a) => !(a.length > 1 && a[0] === '-')), // filter out the flags pushed by `permissive`
+    }, ui);
+    ui.close();
+}
+process.on('SIGINT', () => {
+    process.exit(130);
+});
+main()
+    .catch(console.error)
+    .then(() => process.exit(0));
+function showHelp() {
+    console.log(chalk_1.default.blueBright(`
+     ____  _    _   _ _____ ____  ____  ___ _   _ _____ 
+    | __ )| |  | | | | ____|  _ \\|  _ \\|_ _| \\ | |_   _|
+    |  _ \\| |  | | | |  _| | |_) | |_) || ||  \\| | | |  
+    | |_) | |__| |_| | |___|  __/|  _ < | || |\\  | | |  
+    |____/|_____\\___/|_____|_|   |_| \\_\\___|_| \\_| |_|  `));
+    console.log(chalk_1.default.blue(`                     TON development for professionals`));
+    console.log(``);
+    console.log(` Usage: blueprint [OPTIONS] COMMAND [ARGS]`);
+    console.log(``);
+    console.log(chalk_1.default.cyanBright(`  blueprint create`) +
+        `\t` +
+        chalk_1.default.whiteBright(`create a new contract with .fc source, .ts wrapper, .spec.ts test`));
+    console.log(`\t\t\t` + chalk_1.default.gray(`blueprint create ContractName`));
+    console.log(chalk_1.default.cyanBright(`  blueprint build`) +
+        `\t` +
+        chalk_1.default.whiteBright(`builds a contract that has a .compile.ts file`));
+    console.log(`\t\t\t` + chalk_1.default.gray(`blueprint build ContractName`));
+    console.log(chalk_1.default.cyanBright(`  blueprint test`) +
+        `\t` +
+        chalk_1.default.whiteBright(`run the full project test suite with all .spec.ts files`));
+    console.log(`\t\t\t` + chalk_1.default.gray(`blueprint test`));
+    console.log(chalk_1.default.cyanBright(`  blueprint run `) +
+        `\t` +
+        chalk_1.default.whiteBright(`runs a script from 'scripts' directory (eg. a deploy script)`));
+    console.log(`\t\t\t` + chalk_1.default.gray(`blueprint run deployContractName`));
+    console.log(chalk_1.default.cyanBright(`  blueprint help`) +
+        `\t` +
+        chalk_1.default.whiteBright(`shows more detailed help, also see https://github.com/ton-community/blueprint`));
+    console.log(`\t\t\t` + chalk_1.default.gray(`blueprint help`));
+    console.log(``);
+}

package/dist/cli/create.d.ts

@@ -0,0 +1,6 @@
+import { Runner } from './cli';
+export declare const templateTypes: {
+    name: string;
+    value: string;
+}[];
+export declare const create: Runner;

package/dist/cli/create.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = exports.templateTypes = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const template_1 = require("../template");
+const utils_1 = require("../utils");
+const arg_1 = __importDefault(require("arg"));
+const build_1 = require("./build");
+function toSnakeCase(v) {
+    const r = v.replace(/[A-Z]/g, (sub) => '_' + sub.toLowerCase());
+    return r[0] === '_' ? r.substring(1) : r;
+}
+async function createFile(templatePath, realPath, replaces) {
+    const template = (await (0, promises_1.readFile)(templatePath)).toString('utf-8');
+    const lines = template.split('\n');
+    const fileName = (0, template_1.executeTemplate)(lines.shift(), replaces);
+    const contents = (0, template_1.executeTemplate)(lines.join('\n'), replaces);
+    const p = path_1.default.join(realPath, fileName);
+    const file = await (0, promises_1.open)(p, 'a+');
+    if ((await file.stat()).size > 0) {
+        console.warn(`${p} already exists, not changing.`);
+        await file.close();
+        return;
+    }
+    await file.writeFile(contents);
+    await file.close();
+}
+async function createFiles(templatePath, realPath, replaces) {
+    const contents = await (0, promises_1.readdir)(templatePath);
+    for (const file of contents) {
+        const tp = path_1.default.join(templatePath, file);
+        const rp = path_1.default.join(realPath, file);
+        if ((await (0, promises_1.lstat)(tp)).isDirectory()) {
+            await createFiles(tp, rp, replaces);
+        }
+        else {
+            await (0, promises_1.mkdir)(path_1.default.dirname(rp), {
+                recursive: true,
+            });
+            await createFile(tp, realPath, replaces);
+        }
+    }
+}
+exports.templateTypes = [
+    {
+        name: 'An empty contract (FunC)',
+        value: 'func-empty',
+    },
+    {
+        name: 'A simple counter contract (FunC)',
+        value: 'func-counter',
+    },
+    {
+        name: 'An empty contract (TACT)',
+        value: 'tact-empty',
+    },
+    {
+        name: 'A simple counter contract (TACT)',
+        value: 'tact-counter',
+    },
+];
+const create = async (args, ui) => {
+    const localArgs = (0, arg_1.default)({
+        '--type': String,
+    });
+    const name = args._.length > 1 && args._[1].trim().length > 0
+        ? args._[1].trim()
+        : 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' || !/^[A-Z][a-zA-Z0-9]*$/.test(name))
+        throw new Error(`Cannot create a contract with the name '${name}'`);
+    const which = (await (0, utils_1.selectOption)(exports.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 replaces = {
+        name,
+        loweredName: name.substring(0, 1).toLowerCase() + name.substring(1),
+        snakeName,
+        contractPath: 'contracts/' + snakeName + '.' + (lang === 'func' ? 'fc' : 'tact'),
+    };
+    await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, 'common'), process.cwd(), replaces);
+    await createFiles(path_1.default.join(template_1.TEMPLATES_DIR, lang, template), process.cwd(), replaces);
+    if (lang === 'tact') {
+        await (0, build_1.buildOne)(name, ui);
+    }
+};
+exports.create = create;

package/dist/cli/help.d.ts

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

package/dist/cli/help.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = void 0;
+const create_1 = require("./create");
+const helpMessages = {
+    help: `Usage: blueprint help [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]
+
+List of available commands:
+- create
+- run
+- build
+- help
+- test`,
+    create: `Usage: blueprint create [contract name] [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:
+${create_1.templateTypes.map((t) => `${t.value} - ${t.name}`).join('\n')}`,
+    run: `Usage: blueprint run [script name] [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.
+--tonconnect, --tonhub, --deeplink, --mnemonic - specifies the deployer to use when running the script. If not specified on the command line, it will be asked interactively.
+--tonscan, --tonapi, --toncx, --dton - specifies the network explorer to use when displaying links to the deployed contracts. Default: tonscan.`,
+    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.`,
+    test: `Usage: blueprint test
+
+Just runs \`npm test\`, which by default runs \`jest\`.`,
+};
+const help = async (args, ui) => {
+    const cmd = args._.length >= 2 ? args._[1].toLowerCase() : '';
+    const helpMessage = cmd in helpMessages ? helpMessages[cmd] : helpMessages['help'];
+    ui.write(helpMessage);
+};
+exports.help = help;

package/dist/cli/run.d.ts

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

package/dist/cli/run.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const createNetworkProvider_1 = require("../network/createNetworkProvider");
+const utils_1 = require("../utils");
+const run = async (args, ui) => {
+    require('ts-node/register');
+    const { module: mod } = await (0, utils_1.selectFile)(await (0, utils_1.findScripts)(), {
+        ui,
+        hint: args._.length > 1 && args._[1].length > 0 ? args._[1] : undefined,
+    });
+    if (typeof mod.run !== 'function') {
+        throw new Error('Function `run` is missing!');
+    }
+    const networkProvider = await (0, createNetworkProvider_1.createNetworkProvider)(ui);
+    await mod.run(networkProvider, args._.slice(2));
+};
+exports.run = run;

package/dist/cli/test.d.ts

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

package/dist/cli/test.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const child_process_1 = require("child_process");
+const test = async () => {
+    require('ts-node/register');
+    (0, child_process_1.execSync)('npm test', { stdio: 'inherit' });
+};
+exports.test = test;

package/dist/compile/CompilerConfig.d.ts

@@ -0,0 +1,21 @@
+import { SourceResolver, SourcesMap, SourcesArray } from '@ton-community/func-js';
+import { Cell } from 'ton-core';
+export type CommonCompilerConfig = {
+    preCompileHook?: () => Promise<void>;
+    postCompileHook?: (code: Cell) => Promise<void>;
+};
+export type TactCompilerConfig = {
+    lang: 'tact';
+    target: string;
+};
+export type FuncCompilerConfig = {
+    lang?: 'func';
+    optLevel?: number;
+} & ({
+    targets: string[];
+    sources?: SourceResolver | SourcesMap;
+} | {
+    targets?: string[];
+    sources: SourcesArray;
+});
+export type CompilerConfig = (TactCompilerConfig | FuncCompilerConfig) & CommonCompilerConfig;

package/dist/compile/CompilerConfig.js

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