@ton/blueprint 0.10.0

package/dist/templates/func/counter/wrappers/wrapper.ts.template

@@ -0,0 +1,67 @@
+{{name}}.ts
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from 'ton-core';
+
+export type {{name}}Config = {
+    id: number;
+    counter: number;
+};
+
+export function {{loweredName}}ConfigToCell(config: {{name}}Config): Cell {
+    return beginCell().storeUint(config.id, 32).storeUint(config.counter, 32).endCell();
+}
+
+export const Opcodes = {
+    increase: 0x7e8764ef,
+};
+
+export class {{name}} implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new {{name}}(address);
+    }
+
+    static createFromConfig(config: {{name}}Config, code: Cell, workchain = 0) {
+        const data = {{loweredName}}ConfigToCell(config);
+        const init = { code, data };
+        return new {{name}}(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async sendIncrease(
+        provider: ContractProvider,
+        via: Sender,
+        opts: {
+            increaseBy: number;
+            value: bigint;
+            queryID?: number;
+        }
+    ) {
+        await provider.internal(via, {
+            value: opts.value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(Opcodes.increase, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.increaseBy, 32)
+                .endCell(),
+        });
+    }
+
+    async getCounter(provider: ContractProvider) {
+        const result = await provider.get('get_counter', []);
+        return result.stack.readNumber();
+    }
+
+    async getID(provider: ContractProvider) {
+        const result = await provider.get('get_id', []);
+        return result.stack.readNumber();
+    }
+}

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

@@ -0,0 +1,6 @@
+{{snakeName}}.fc
+#include "imports/stdlib.fc";
+
+() recv_internal(int my_balance, int msg_value, cell in_msg_full, slice in_msg_body) impure {
+
+}

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

@@ -0,0 +1,14 @@
+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({}, await compile('{{name}}')));
+
+    await {{loweredName}}.sendDeploy(provider.sender(), toNano('0.05'));
+
+    await provider.waitForDeploy({{loweredName}}.address);
+
+    // run methods on `{{loweredName}}`
+}

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

@@ -0,0 +1,39 @@
+{{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({}, 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
+    });
+});

package/dist/templates/func/empty/wrappers/wrapper.ts.template

@@ -0,0 +1,30 @@
+{{name}}.ts
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from 'ton-core';
+
+export type {{name}}Config = {};
+
+export function {{loweredName}}ConfigToCell(config: {{name}}Config): Cell {
+    return beginCell().endCell();
+}
+
+export class {{name}} implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new {{name}}(address);
+    }
+
+    static createFromConfig(config: {{name}}Config, code: Cell, workchain = 0) {
+        const data = {{loweredName}}ConfigToCell(config);
+        const init = { code, data };
+        return new {{name}}(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+}

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

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

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

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

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

@@ -0,0 +1,29 @@
+{{snakeName}}.tact
+import "@stdlib/deploy";
+
+message Add {
+    queryId: Int as uint64;
+    amount: Int as uint32;
+}
+
+contract {{name}} with Deployable {
+    id: Int as uint32;
+    counter: Int as uint32;
+
+    init(id: Int) {
+        self.id = id;
+        self.counter = 0;
+    }
+
+    receive(msg: Add) {
+        self.counter = (self.counter + msg.amount);
+    }
+
+    get fun counter(): Int {
+        return self.counter;
+    }
+
+    get fun id(): Int {
+        return self.id;
+    }
+}

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

@@ -0,0 +1,23 @@
+deploy{{name}}.ts
+import { toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import { NetworkProvider } from '@ton-community/blueprint';
+
+export async function run(provider: NetworkProvider) {
+    const {{loweredName}} = provider.open(await {{name}}.fromInit(BigInt(Math.floor(Math.random() * 10000))));
+
+    await {{loweredName}}.send(
+        provider.sender(),
+        {
+            value: toNano('0.05'),
+        },
+        {
+            $$type: 'Deploy',
+            queryId: 0n,
+        }
+    );
+
+    await provider.waitForDeploy({{loweredName}}.address);
+
+    console.log('ID', await {{loweredName}}.getId());
+}

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

@@ -0,0 +1,45 @@
+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}}.fromAddress(address));
+
+    const counterBefore = await {{loweredName}}.getCounter();
+
+    await {{loweredName}}.send(
+        provider.sender(),
+        {
+            value: toNano('0.05'),
+        },
+        {
+            $$type: 'Add',
+            queryId: 0n,
+            amount: 1n,
+        }
+    );
+
+    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/tact/counter/tests/spec.ts.template

@@ -0,0 +1,82 @@
+{{name}}.spec.ts
+import { Blockchain, SandboxContract } from '@ton-community/sandbox';
+import { toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import '@ton-community/test-utils';
+
+describe('{{name}}', () => {
+    let blockchain: Blockchain;
+    let {{loweredName}}: SandboxContract<{{name}}>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+
+        {{loweredName}} = blockchain.openContract(await {{name}}.fromInit(0n));
+
+        const deployer = await blockchain.treasury('deployer');
+
+        const deployResult = await {{loweredName}}.send(
+            deployer.getSender(),
+            {
+                value: toNano('0.05'),
+            },
+            {
+                $$type: 'Deploy',
+                queryId: 0n,
+            }
+        );
+
+        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 = BigInt(Math.floor(Math.random() * 100));
+
+            console.log('increasing by', increaseBy);
+
+            const increaseResult = await {{loweredName}}.send(
+                increaser.getSender(),
+                {
+                    value: toNano('0.05'),
+                },
+                {
+                    $$type: 'Add',
+                    queryId: 0n,
+                    amount: increaseBy,
+                }
+            );
+
+            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);
+        }
+    });
+});

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

@@ -0,0 +1,8 @@
+{{snakeName}}.tact
+import "@stdlib/deploy";
+
+contract {{name}} with Deployable {
+    init() {
+        
+    }
+}

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

@@ -0,0 +1,23 @@
+deploy{{name}}.ts
+import { toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import { NetworkProvider } from '@ton-community/blueprint';
+
+export async function run(provider: NetworkProvider) {
+    const {{loweredName}} = provider.open(await {{name}}.fromInit());
+
+    await {{loweredName}}.send(
+        provider.sender(),
+        {
+            value: toNano('0.05'),
+        },
+        {
+            $$type: 'Deploy',
+            queryId: 0n,
+        }
+    );
+
+    await provider.waitForDeploy({{loweredName}}.address);
+
+    // run methods on `{{loweredName}}`
+}

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

@@ -0,0 +1,41 @@
+{{name}}.spec.ts
+import { Blockchain, SandboxContract } from '@ton-community/sandbox';
+import { toNano } from 'ton-core';
+import { {{name}} } from '../wrappers/{{name}}';
+import '@ton-community/test-utils';
+
+describe('{{name}}', () => {
+    let blockchain: Blockchain;
+    let {{loweredName}}: SandboxContract<{{name}}>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+
+        {{loweredName}} = blockchain.openContract(await {{name}}.fromInit());
+
+        const deployer = await blockchain.treasury('deployer');
+
+        const deployResult = await {{loweredName}}.send(
+            deployer.getSender(),
+            {
+                value: toNano('0.05'),
+            },
+            {
+                $$type: 'Deploy',
+                queryId: 0n,
+            }
+        );
+
+        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
+    });
+});

package/dist/ui/InquirerUIProvider.d.ts

@@ -0,0 +1,12 @@
+import { UIProvider } from '../ui/UIProvider';
+export declare class InquirerUIProvider implements UIProvider {
+    #private;
+    constructor();
+    write(message: string): void;
+    prompt(message: string): Promise<boolean>;
+    input(message: string): Promise<string>;
+    choose<T>(message: string, choices: T[], display: (v: T) => string): Promise<T>;
+    setActionPrompt(message: string): void;
+    clearActionPrompt(): void;
+    close(): void;
+}

package/dist/ui/InquirerUIProvider.js

@@ -0,0 +1,70 @@
+"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 _InquirerUIProvider_bottomBar;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InquirerUIProvider = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+class DestroyableBottomBar extends inquirer_1.default.ui.BottomBar {
+    destroy() {
+        this.close();
+    }
+}
+class InquirerUIProvider {
+    constructor() {
+        _InquirerUIProvider_bottomBar.set(this, void 0);
+        __classPrivateFieldSet(this, _InquirerUIProvider_bottomBar, new DestroyableBottomBar(), "f");
+    }
+    write(message) {
+        __classPrivateFieldGet(this, _InquirerUIProvider_bottomBar, "f").log.write(message);
+    }
+    async prompt(message) {
+        const { prompt } = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'prompt',
+            message,
+        });
+        return prompt;
+    }
+    async input(message) {
+        const { val } = await inquirer_1.default.prompt({
+            name: 'val',
+            message: message,
+        });
+        return val;
+    }
+    async choose(message, choices, display) {
+        const { choice } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'choice',
+                message: message,
+                choices: choices.map((c) => ({ name: display(c), value: c })),
+            },
+        ]);
+        return choice;
+    }
+    setActionPrompt(message) {
+        __classPrivateFieldGet(this, _InquirerUIProvider_bottomBar, "f").updateBottomBar(message);
+    }
+    clearActionPrompt() {
+        __classPrivateFieldGet(this, _InquirerUIProvider_bottomBar, "f").updateBottomBar('');
+    }
+    close() {
+        __classPrivateFieldGet(this, _InquirerUIProvider_bottomBar, "f").destroy();
+    }
+}
+exports.InquirerUIProvider = InquirerUIProvider;
+_InquirerUIProvider_bottomBar = new WeakMap();

package/dist/ui/UIProvider.d.ts

@@ -0,0 +1,8 @@
+export interface UIProvider {
+    write(message: string): void;
+    prompt(message: string): Promise<boolean>;
+    input(message: string): Promise<string>;
+    choose<T>(message: string, choices: T[], display: (v: T) => string): Promise<T>;
+    setActionPrompt(message: string): void;
+    clearActionPrompt(): void;
+}

package/dist/ui/UIProvider.js

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

package/dist/utils.d.ts

@@ -0,0 +1,39 @@
+import { Address, Cell } from 'ton-core';
+import { UIProvider } from './ui/UIProvider';
+export declare const tonDeepLink: (address: Address, amount: bigint, body?: Cell, stateInit?: Cell) => string;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function oneOrZeroOf<T extends {
+    [k: string]: boolean | undefined;
+}>(options: T): keyof T | undefined;
+export declare const findCompiles: () => Promise<{
+    path: string;
+    name: string;
+}[]>;
+export declare const findScripts: () => Promise<{
+    path: string;
+    name: string;
+}[]>;
+export declare function selectOption(options: {
+    name: string;
+    value: string;
+}[], opts: {
+    ui: UIProvider;
+    msg: string;
+    hint?: string;
+}): Promise<{
+    name: string;
+    value: string;
+}>;
+export declare function selectFile(files: {
+    name: string;
+    path: string;
+}[], opts: {
+    ui: UIProvider;
+    hint?: string;
+    import?: boolean;
+}): Promise<{
+    module: any;
+    name: string;
+    path: string;
+}>;
+export declare function getExplorerLink(address: string, network: string, explorer: string): string;