@ton/blueprint 0.24.0 → 0.25.0-beta.1

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

@@ -0,0 +1,9 @@
+{{name}}.compile.ts
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    lang: 'tolk',
+    entrypoint: '{{contractPath}}',
+    withStackComments: true,    // Fift output will contain comments, if you wish to debug its output
+    experimentalOptions: '',    // you can pass experimental compiler options here
+};

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

@@ -0,0 +1,71 @@
+{{snakeName}}.tolk
+// simple counter contract in Tolk language
+
+const OP_INCREASE = 0x7e8764ef;  // arbitrary 32-bit number, equal to OP_INCREASE in wrappers/CounterContract.ts
+
+// 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 ctxID: int;
+global ctxCounter: int;
+
+// loadData populates storage variables from persistent storage
+fun loadData() {
+    var ds = getContractData().beginParse();
+
+    ctxID = ds.loadUint(32);
+    ctxCounter = ds.loadUint(32);
+
+    ds.assertEndOfSlice();
+}
+
+// saveData stores storage variables as a cell into persistent storage
+fun saveData() {
+    setContractData(
+        beginCell()
+        .storeUint(ctxID, 32)
+        .storeUint(ctxCounter, 32)
+        .endCell()
+    );
+}
+
+// onInternalMessage is the main entrypoint; it's called when a contract receives an internal message from other contracts
+fun onInternalMessage(myBalance: int, msgValue: int, msgFull: cell, msgBody: slice) {
+    if (msgBody.isEndOfSlice()) { // ignore all empty messages
+        return;
+    }
+
+    var cs: slice = msgFull.beginParse();
+    val flags = cs.loadMessageFlags();
+    if (isMessageBounced(flags)) { // ignore all bounced messages
+        return;
+    }
+
+    loadData(); // here we populate the storage variables
+
+    val op = msgBody.loadMessageOp(); // by convention, the first 32 bits of incoming message is the op
+    val queryID = msgBody.loadMessageQueryId(); // also by convention, the next 64 bits contain the "query id", although this is not always the case
+
+    if (op == OP_INCREASE) {
+        val increaseBy = msgBody.loadUint(32);
+        ctxCounter += increaseBy;
+        saveData();
+        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
+// note that unlike in many other smart contract VMs, get methods cannot be called by other contracts
+
+get currentCounter(): int {
+    loadData();
+    return ctxCounter;
+}
+
+get initialId(): int {
+    loadData();
+    return ctxID;
+}

package/dist/templates/tolk/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/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/tolk/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/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/tolk/counter/tests/spec.ts.template

@@ -0,0 +1,82 @@
+{{name}}.spec.ts
+import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
+import { Cell, toNano } from '@ton/core';
+import { {{name}} } from '../wrappers/{{name}}';
+import '@ton/test-utils';
+import { compile } from '@ton/blueprint';
+
+describe('{{name}}', () => {
+    let code: Cell;
+
+    beforeAll(async () => {
+        code = await compile('{{name}}');
+    });
+
+    let blockchain: Blockchain;
+    let deployer: SandboxContract<TreasuryContract>;
+    let {{loweredName}}: SandboxContract<{{name}}>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+
+        {{loweredName}} = blockchain.openContract(
+            {{name}}.createFromConfig(
+                {
+                    id: 0,
+                    counter: 0,
+                },
+                code
+            )
+        );
+
+        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);
+        }
+    });
+});

package/dist/templates/tolk/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 = {
+    OP_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.OP_INCREASE, 32)
+                .storeUint(opts.queryID ?? 0, 64)
+                .storeUint(opts.increaseBy, 32)
+                .endCell(),
+        });
+    }
+
+    async getCounter(provider: ContractProvider) {
+        const result = await provider.get('currentCounter', []);
+        return result.stack.readNumber();
+    }
+
+    async getID(provider: ContractProvider) {
+        const result = await provider.get('initialId', []);
+        return result.stack.readNumber();
+    }
+}

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

@@ -0,0 +1,4 @@
+{{snakeName}}.tolk
+fun onInternalMessage(myBalance: int, msgValue: int, msgFull: cell, msgBody: slice) {
+
+}

package/dist/templates/tolk/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/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/tolk/empty/tests/spec.ts.template

@@ -0,0 +1,40 @@
+{{name}}.spec.ts
+import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
+import { Cell, toNano } from '@ton/core';
+import { {{name}} } from '../wrappers/{{name}}';
+import '@ton/test-utils';
+import { compile } from '@ton/blueprint';
+
+describe('{{name}}', () => {
+    let code: Cell;
+
+    beforeAll(async () => {
+        code = await compile('{{name}}');
+    });
+
+    let blockchain: Blockchain;
+    let deployer: SandboxContract<TreasuryContract>;
+    let {{loweredName}}: SandboxContract<{{name}}>;
+
+    beforeEach(async () => {
+        blockchain = await Blockchain.create();
+
+        {{loweredName}} = blockchain.openContract({{name}}.createFromConfig({}, code));
+
+        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/tolk/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/tolk/not-separated-common/wrappers/compile.ts.template

@@ -0,0 +1,9 @@
+{{name}}.compile.ts
+import { CompilerConfig } from '@ton/blueprint';
+
+export const compile: CompilerConfig = {
+    lang: 'tolk',
+    entrypoint: '{{contractPath}}',
+    withStackComments: true,    // Fift output will contain comments, if you wish to debug its output
+    experimentalOptions: '',    // you can pass experimental compiler options here
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ton/blueprint",
-  "version": "0.24.0",
+  "version": "0.25.0-beta.1",
   "description": "Framework for development of TON smart contracts",
   "main": "dist/index.js",
   "bin": "./dist/cli/cli.js",
@@ -35,9 +35,11 @@
   },
   "dependencies": {
     "@tact-lang/compiler": "^1.4.0",
-    "@ton-community/func-js": "^0.7.0",
+    "@ton-community/func-js": "0.8.0-beta.1",
+    "@ton/tolk-js": "^0.6.0",
     "@tonconnect/sdk": "^2.2.0",
     "arg": "^5.0.2",
+    "axios": "^1.7.7",
     "chalk": "^4.1.0",
     "dotenv": "^16.1.4",
     "inquirer": "^8.2.5",