@ton/blueprint 0.10.0

package/dist/network/send/SendProvider.js

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

package/dist/network/send/TonConnectProvider.d.ts

@@ -0,0 +1,12 @@
+import { Address, Cell, StateInit } from 'ton-core';
+import { SendProvider } from './SendProvider';
+import { Storage } from '../storage/Storage';
+import { UIProvider } from '../../ui/UIProvider';
+export declare class TonConnectProvider implements SendProvider {
+    #private;
+    constructor(storage: Storage, ui: UIProvider);
+    connect(): Promise<void>;
+    address(): Address | undefined;
+    private connectWallet;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<import("@tonconnect/sdk").SendTransactionResponse>;
+}

package/dist/network/send/TonConnectProvider.js

@@ -0,0 +1,108 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TonConnectStorage_inner, _TonConnectProvider_connector, _TonConnectProvider_ui;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonConnectProvider = void 0;
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const sdk_1 = __importDefault(require("@tonconnect/sdk"));
+const ton_core_1 = require("ton-core");
+class TonConnectStorage {
+    constructor(inner) {
+        _TonConnectStorage_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _TonConnectStorage_inner, inner, "f");
+    }
+    async setItem(key, value) {
+        return await __classPrivateFieldGet(this, _TonConnectStorage_inner, "f").setItem(key, value);
+    }
+    async getItem(key) {
+        return await __classPrivateFieldGet(this, _TonConnectStorage_inner, "f").getItem(key);
+    }
+    async removeItem(key) {
+        return await __classPrivateFieldGet(this, _TonConnectStorage_inner, "f").removeItem(key);
+    }
+}
+_TonConnectStorage_inner = new WeakMap();
+function isRemote(walletInfo) {
+    return 'universalLink' in walletInfo && 'bridgeUrl' in walletInfo;
+}
+class TonConnectProvider {
+    constructor(storage, ui) {
+        _TonConnectProvider_connector.set(this, void 0);
+        _TonConnectProvider_ui.set(this, void 0);
+        __classPrivateFieldSet(this, _TonConnectProvider_connector, new sdk_1.default({
+            storage: new TonConnectStorage(storage),
+            manifestUrl: 'https://raw.githubusercontent.com/ton-defi-org/tonconnect-manifest-temp/main/tonconnect-manifest.json',
+        }), "f");
+        __classPrivateFieldSet(this, _TonConnectProvider_ui, ui, "f");
+    }
+    async connect() {
+        await this.connectWallet();
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").write(`Connected to wallet at address: ${ton_core_1.Address.parse(__classPrivateFieldGet(this, _TonConnectProvider_connector, "f").wallet.account.address).toString()}\n`);
+    }
+    address() {
+        if (!__classPrivateFieldGet(this, _TonConnectProvider_connector, "f").wallet)
+            return undefined;
+        return ton_core_1.Address.parse(__classPrivateFieldGet(this, _TonConnectProvider_connector, "f").wallet.account.address);
+    }
+    async connectWallet() {
+        const wallets = (await __classPrivateFieldGet(this, _TonConnectProvider_connector, "f").getWallets()).filter(isRemote);
+        await __classPrivateFieldGet(this, _TonConnectProvider_connector, "f").restoreConnection();
+        if (__classPrivateFieldGet(this, _TonConnectProvider_connector, "f").wallet) {
+            return;
+        }
+        const wallet = await __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").choose('Choose your wallet', wallets, (w) => w.name);
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").setActionPrompt('Connecting to wallet...');
+        const url = __classPrivateFieldGet(this, _TonConnectProvider_connector, "f").connect({
+            universalLink: wallet.universalLink,
+            bridgeUrl: wallet.bridgeUrl,
+        });
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").write('\n');
+        qrcode_terminal_1.default.generate(url, { small: true }, (qr) => __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").write(qr));
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").write('\n' + url + '\n\n');
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").setActionPrompt('Scan the QR code in your wallet or open the link...');
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _TonConnectProvider_connector, "f").onStatusChange((w) => {
+                if (w) {
+                    resolve();
+                }
+                else {
+                    reject('Wallet is not connected');
+                }
+            }, reject);
+        });
+    }
+    async sendTransaction(address, amount, payload, stateInit) {
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").setActionPrompt('Sending transaction. Approve in your wallet...');
+        const result = await __classPrivateFieldGet(this, _TonConnectProvider_connector, "f").sendTransaction({
+            validUntil: Date.now() + 5 * 60 * 1000,
+            messages: [
+                {
+                    address: address.toString(),
+                    amount: amount.toString(),
+                    payload: payload?.toBoc().toString('base64'),
+                    stateInit: stateInit
+                        ? (0, ton_core_1.beginCell)().storeWritable((0, ton_core_1.storeStateInit)(stateInit)).endCell().toBoc().toString('base64')
+                        : undefined,
+                },
+            ],
+        });
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").clearActionPrompt();
+        __classPrivateFieldGet(this, _TonConnectProvider_ui, "f").write('Sent transaction');
+        return result;
+    }
+}
+exports.TonConnectProvider = TonConnectProvider;
+_TonConnectProvider_connector = new WeakMap(), _TonConnectProvider_ui = new WeakMap();

package/dist/network/send/TonHubProvider.d.ts

@@ -0,0 +1,16 @@
+import { Address, Cell, StateInit } from 'ton-core';
+import { SendProvider } from './SendProvider';
+import { Storage } from '../storage/Storage';
+import { UIProvider } from '../../ui/UIProvider';
+export declare class TonHubProvider implements SendProvider {
+    #private;
+    constructor(network: 'mainnet' | 'testnet', storage: Storage, ui: UIProvider);
+    private getExistingSession;
+    private getSession;
+    connect(): Promise<void>;
+    address(): Address | undefined;
+    sendTransaction(address: Address, amount: bigint, payload?: Cell, stateInit?: StateInit): Promise<{
+        type: "success";
+        response: string;
+    }>;
+}

package/dist/network/send/TonHubProvider.js

@@ -0,0 +1,110 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TonHubProvider_connector, _TonHubProvider_storage, _TonHubProvider_ui, _TonHubProvider_session;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonHubProvider = void 0;
+const ton_core_1 = require("ton-core");
+const ton_x_1 = require("ton-x");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const KEY_NAME = 'tonhub_session';
+class TonHubProvider {
+    constructor(network, storage, ui) {
+        _TonHubProvider_connector.set(this, void 0);
+        _TonHubProvider_storage.set(this, void 0);
+        _TonHubProvider_ui.set(this, void 0);
+        _TonHubProvider_session.set(this, void 0);
+        __classPrivateFieldSet(this, _TonHubProvider_connector, new ton_x_1.TonhubConnector({
+            network,
+        }), "f");
+        __classPrivateFieldSet(this, _TonHubProvider_storage, storage, "f");
+        __classPrivateFieldSet(this, _TonHubProvider_ui, ui, "f");
+    }
+    async getExistingSession() {
+        const sessionString = await __classPrivateFieldGet(this, _TonHubProvider_storage, "f").getItem(KEY_NAME);
+        if (sessionString === null)
+            return undefined;
+        let session = JSON.parse(sessionString);
+        const state = await __classPrivateFieldGet(this, _TonHubProvider_connector, "f").getSessionState(session.id);
+        if (state.state === 'ready') {
+            session = {
+                ...state,
+                id: session.id,
+                seed: session.seed,
+            };
+            await __classPrivateFieldGet(this, _TonHubProvider_storage, "f").setItem(KEY_NAME, JSON.stringify(session));
+            return session;
+        }
+    }
+    async getSession() {
+        const existing = await this.getExistingSession();
+        if (existing !== undefined)
+            return existing;
+        const createdSession = await __classPrivateFieldGet(this, _TonHubProvider_connector, "f").createNewSession({
+            name: 'TON template project',
+            url: 'https://example.com/',
+        });
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").setActionPrompt('Connecting to wallet...\n');
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").write('\n');
+        qrcode_terminal_1.default.generate(createdSession.link, { small: true }, (qr) => __classPrivateFieldGet(this, _TonHubProvider_ui, "f").write(qr));
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").write('\n' + createdSession.link + '\n\n');
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").setActionPrompt('Scan the QR code in your wallet or open the link...');
+        const state = await __classPrivateFieldGet(this, _TonHubProvider_connector, "f").awaitSessionReady(createdSession.id, 5 * 60 * 1000);
+        if (state.state === 'ready') {
+            const session = {
+                ...state,
+                id: createdSession.id,
+                seed: createdSession.seed,
+            };
+            await __classPrivateFieldGet(this, _TonHubProvider_storage, "f").setItem(KEY_NAME, JSON.stringify(session));
+            return session;
+        }
+        throw new Error('Could not create new session');
+    }
+    async connect() {
+        __classPrivateFieldSet(this, _TonHubProvider_session, await this.getSession(), "f");
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").write(`Connected to wallet at address: ${ton_core_1.Address.parse(__classPrivateFieldGet(this, _TonHubProvider_session, "f").wallet.address).toString()}\n`);
+    }
+    address() {
+        if (!__classPrivateFieldGet(this, _TonHubProvider_session, "f"))
+            return undefined;
+        return ton_core_1.Address.parse(__classPrivateFieldGet(this, _TonHubProvider_session, "f").wallet.address);
+    }
+    async sendTransaction(address, amount, payload, stateInit) {
+        if (!__classPrivateFieldGet(this, _TonHubProvider_session, "f"))
+            throw new Error('TonhubProvider is not connected');
+        const request = {
+            seed: __classPrivateFieldGet(this, _TonHubProvider_session, "f").seed,
+            appPublicKey: __classPrivateFieldGet(this, _TonHubProvider_session, "f").wallet.appPublicKey,
+            to: address.toString(),
+            value: amount.toString(),
+            timeout: 5 * 60 * 1000,
+            payload: payload ? payload.toBoc().toString('base64') : undefined,
+            stateInit: stateInit
+                ? (0, ton_core_1.beginCell)().storeWritable((0, ton_core_1.storeStateInit)(stateInit)).endCell().toBoc().toString('base64')
+                : undefined,
+        };
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").setActionPrompt('Sending transaction. Approve it in your wallet...');
+        const response = await __classPrivateFieldGet(this, _TonHubProvider_connector, "f").requestTransaction(request);
+        if (response.type !== 'success') {
+            throw new Error(`Tonhub transaction request was not successful (${response.type})`);
+        }
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").clearActionPrompt();
+        __classPrivateFieldGet(this, _TonHubProvider_ui, "f").write('Sent transaction');
+        return response;
+    }
+}
+exports.TonHubProvider = TonHubProvider;
+_TonHubProvider_connector = new WeakMap(), _TonHubProvider_storage = new WeakMap(), _TonHubProvider_ui = new WeakMap(), _TonHubProvider_session = new WeakMap();

package/dist/network/storage/FSStorage.d.ts

@@ -0,0 +1,8 @@
+import { Storage } from './Storage';
+export declare class FSStorage implements Storage {
+    #private;
+    constructor(path: string);
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string | null>;
+    removeItem(key: string): Promise<void>;
+}

package/dist/network/storage/FSStorage.js

@@ -0,0 +1,53 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _FSStorage_instances, _FSStorage_path, _FSStorage_readObject, _FSStorage_writeObject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSStorage = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class FSStorage {
+    constructor(path) {
+        _FSStorage_instances.add(this);
+        _FSStorage_path.set(this, void 0);
+        __classPrivateFieldSet(this, _FSStorage_path, path, "f");
+    }
+    async setItem(key, value) {
+        const obj = await __classPrivateFieldGet(this, _FSStorage_instances, "m", _FSStorage_readObject).call(this);
+        obj[key] = value;
+        await __classPrivateFieldGet(this, _FSStorage_instances, "m", _FSStorage_writeObject).call(this, obj);
+    }
+    async getItem(key) {
+        const obj = await __classPrivateFieldGet(this, _FSStorage_instances, "m", _FSStorage_readObject).call(this);
+        return obj[key] ?? null;
+    }
+    async removeItem(key) {
+        const obj = await __classPrivateFieldGet(this, _FSStorage_instances, "m", _FSStorage_readObject).call(this);
+        delete obj[key];
+        await __classPrivateFieldGet(this, _FSStorage_instances, "m", _FSStorage_writeObject).call(this, obj);
+    }
+}
+exports.FSStorage = FSStorage;
+_FSStorage_path = new WeakMap(), _FSStorage_instances = new WeakSet(), _FSStorage_readObject = async function _FSStorage_readObject() {
+    try {
+        return JSON.parse((await promises_1.default.readFile(__classPrivateFieldGet(this, _FSStorage_path, "f"))).toString('utf-8'));
+    }
+    catch (e) {
+        return {};
+    }
+}, _FSStorage_writeObject = async function _FSStorage_writeObject(obj) {
+    await promises_1.default.mkdir(path_1.default.dirname(__classPrivateFieldGet(this, _FSStorage_path, "f")), { recursive: true });
+    await promises_1.default.writeFile(__classPrivateFieldGet(this, _FSStorage_path, "f"), JSON.stringify(obj));
+};

package/dist/network/storage/Storage.d.ts

@@ -0,0 +1,18 @@
+export interface Storage {
+    /**
+     * Saves the `value` to the storage. Value can be accessed later by the `key`. Implementation may use backend as a storage due to the fact that the function returns a promise.
+     * @param key key to access to the value later.
+     * @param value value to save.
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Reads the `value` from the storage. Implementation may use backend as a storage due to the fact that the function returns a promise.
+     * @param key key to access the value.
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Removes the `value` from the storage. Implementation may use backend as a storage due to the fact that the function returns a promise.
+     * @param key key to access the value.
+     */
+    removeItem(key: string): Promise<void>;
+}

package/dist/network/storage/Storage.js

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

package/dist/paths.d.ts

@@ -0,0 +1,12 @@
+export declare const CONTRACTS = "contracts";
+export declare const TESTS = "tests";
+export declare const WRAPPERS = "wrappers";
+export declare const SCRIPTS = "scripts";
+export declare const TEMP = "temp";
+export declare const BUILD = "build";
+export declare const WRAPPERS_DIR: string;
+export declare const SCRIPTS_DIR: string;
+export declare const BUILD_DIR: string;
+export declare const TEMP_DIR: string;
+export declare const CONTRACTS_DIR: string;
+export declare const TESTS_DIR: string;

package/dist/paths.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TESTS_DIR = exports.CONTRACTS_DIR = exports.TEMP_DIR = exports.BUILD_DIR = exports.SCRIPTS_DIR = exports.WRAPPERS_DIR = exports.BUILD = exports.TEMP = exports.SCRIPTS = exports.WRAPPERS = exports.TESTS = exports.CONTRACTS = void 0;
+const path_1 = __importDefault(require("path"));
+exports.CONTRACTS = 'contracts';
+exports.TESTS = 'tests';
+exports.WRAPPERS = 'wrappers';
+exports.SCRIPTS = 'scripts';
+exports.TEMP = 'temp';
+exports.BUILD = 'build';
+exports.WRAPPERS_DIR = path_1.default.join(process.cwd(), exports.WRAPPERS);
+exports.SCRIPTS_DIR = path_1.default.join(process.cwd(), exports.SCRIPTS);
+exports.BUILD_DIR = path_1.default.join(process.cwd(), exports.BUILD);
+exports.TEMP_DIR = path_1.default.join(process.cwd(), exports.TEMP);
+exports.CONTRACTS_DIR = path_1.default.join(process.cwd(), exports.CONTRACTS);
+exports.TESTS_DIR = path_1.default.join(process.cwd(), exports.TESTS);

package/dist/template.d.ts

@@ -0,0 +1,4 @@
+export declare const TEMPLATES_DIR: string;
+export declare function executeTemplate(contents: string, replaces: {
+    [k: string]: string;
+}): string;

package/dist/template.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTemplate = exports.TEMPLATES_DIR = void 0;
+const path_1 = __importDefault(require("path"));
+exports.TEMPLATES_DIR = path_1.default.join(__dirname, 'templates');
+function executeTemplate(contents, replaces) {
+    for (const k in replaces) {
+        contents = contents.replaceAll(`{{${k}}}`, replaces[k]);
+    }
+    return contents;
+}
+exports.executeTemplate = executeTemplate;

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

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

package/dist/templates/func/counter/contracts/contract.fc.template

@@ -0,0 +1,72 @@
+{{snakeName}}.fc
+#include "imports/stdlib.fc";
+
+const op::increase = "op::increase"c; ;; create an opcode from string using the "c" prefix, this results in 0x7e8764ef opcode in this case
+
+;; storage variables
+
+;; id is required to be able to create different instances of counters
+;; since addresses in TON depend on the initial state of the contract
+global int ctx_id;
+global int ctx_counter;
+
+;; load_data populates storage variables using stored data
+() load_data() impure {
+    var ds = get_data().begin_parse();
+
+    ctx_id = ds~load_uint(32);
+    ctx_counter = ds~load_uint(32);
+
+    ds.end_parse();
+}
+
+;; save_data stores storage variables as a cell into persistent storage
+() save_data() impure {
+    set_data(
+        begin_cell()
+            .store_uint(ctx_id, 32)
+            .store_uint(ctx_counter, 32)
+            .end_cell()
+    );
+}
+
+;; recv_internal is the main function of the contract and is called when it receives a message from other contracts
+() recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
+    if (in_msg_body.slice_empty?()) { ;; ignore all empty messages
+        return ();
+    }
+
+    slice cs = in_msg_full.begin_parse();
+    int flags = cs~load_uint(4);
+    if (flags & 1) { ;; ignore all bounced messages
+        return ();
+    }
+
+    load_data(); ;; here we populate the storage variables
+
+    int op = in_msg_body~load_uint(32); ;; by convention, the first 32 bits of incoming message is the op
+    int query_id = in_msg_body~load_uint(64); ;; also by convention, the next 64 bits contain the "query id", although this is not always the case
+
+    if (op == op::increase) {
+        int increase_by = in_msg_body~load_uint(32);
+        ctx_counter += increase_by;
+        save_data();
+        return ();
+    }
+
+    throw(0xffff); ;; if the message contains an op that is not known to this contract, we throw
+}
+
+;; get methods are a means to conveniently read contract data using, for example, HTTP APIs
+;; they are marked with method_id
+;; note that unlike in many other smart contract VMs, get methods cannot be called by other contracts
+
+int get_counter() method_id {
+    load_data();
+    return ctx_counter;
+}
+
+int get_id() method_id {
+    load_data();
+    return ctx_id;
+}

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

@@ -0,0 +1,22 @@
+deploy{{name}}.ts
+import { toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import { compile, NetworkProvider } from '@ton-community/blueprint';
+
+export async function run(provider: NetworkProvider) {
+    const {{loweredName}} = provider.open(
+        {{name}}.createFromConfig(
+            {
+                id: Math.floor(Math.random() * 10000),
+                counter: 0,
+            },
+            await compile('{{name}}')
+        )
+    );
+
+    await {{loweredName}}.sendDeploy(provider.sender(), toNano('0.05'));
+
+    await provider.waitForDeploy({{loweredName}}.address);
+
+    console.log('ID', await {{loweredName}}.getID());
+}

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

@@ -0,0 +1,38 @@
+increment{{name}}.ts
+import { Address, toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import { NetworkProvider, sleep } from '@ton-community/blueprint';
+
+export async function run(provider: NetworkProvider, args: string[]) {
+    const ui = provider.ui();
+
+    const address = Address.parse(args.length > 0 ? args[0] : await ui.input('{{name}} address'));
+
+    if (!(await provider.isContractDeployed(address))) {
+        ui.write(`Error: Contract at address ${address} is not deployed!`);
+        return;
+    }
+
+    const {{loweredName}} = provider.open({{name}}.createFromAddress(address));
+
+    const counterBefore = await {{loweredName}}.getCounter();
+
+    await {{loweredName}}.sendIncrease(provider.sender(), {
+        increaseBy: 1,
+        value: toNano('0.05'),
+    });
+
+    ui.write('Waiting for counter to increase...');
+
+    let counterAfter = await {{loweredName}}.getCounter();
+    let attempt = 1;
+    while (counterAfter === counterBefore) {
+        ui.setActionPrompt(`Attempt ${attempt}`);
+        await sleep(2000);
+        counterAfter = await {{loweredName}}.getCounter();
+        attempt++;
+    }
+
+    ui.clearActionPrompt();
+    ui.write('Counter increased successfully!');
+}

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

@@ -0,0 +1,81 @@
+{{name}}.spec.ts
+import { Blockchain, SandboxContract } from '@ton-community/sandbox';
+import { Cell, toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import '@ton-community/test-utils';
+import { compile } from '@ton-community/blueprint';
+
+describe('{{name}}', () => {
+    let code: Cell;
+
+    beforeAll(async () => {
+        code = await compile('{{name}}');
+    });
+
+    let blockchain: Blockchain;
+    let {{loweredName}}: SandboxContract<{{name}}>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+
+        {{loweredName}} = blockchain.openContract(
+            {{name}}.createFromConfig(
+                {
+                    id: 0,
+                    counter: 0,
+                },
+                code
+            )
+        );
+
+        const deployer = await blockchain.treasury('deployer');
+
+        const deployResult = await {{loweredName}}.sendDeploy(deployer.getSender(), toNano('0.05'));
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: deployer.address,
+            to: {{loweredName}}.address,
+            deploy: true,
+            success: true,
+        });
+    });
+
+    it('should deploy', async () => {
+        // the check is done inside beforeEach
+        // blockchain and {{loweredName}} are ready to use
+    });
+
+    it('should increase counter', async () => {
+        const increaseTimes = 3;
+        for (let i = 0; i < increaseTimes; i++) {
+            console.log(`increase ${i + 1}/${increaseTimes}`);
+
+            const increaser = await blockchain.treasury('increaser' + i);
+
+            const counterBefore = await {{loweredName}}.getCounter();
+
+            console.log('counter before increasing', counterBefore);
+
+            const increaseBy = Math.floor(Math.random() * 100);
+
+            console.log('increasing by', increaseBy);
+
+            const increaseResult = await {{loweredName}}.sendIncrease(increaser.getSender(), {
+                increaseBy,
+                value: toNano('0.05'),
+            });
+
+            expect(increaseResult.transactions).toHaveTransaction({
+                from: increaser.address,
+                to: {{loweredName}}.address,
+                success: true,
+            });
+
+            const counterAfter = await {{loweredName}}.getCounter();
+
+            console.log('counter after increasing', counterAfter);
+
+            expect(counterAfter).toBe(counterBefore + increaseBy);
+        }
+    });
+});