create-ton 0.0.3

package/dist/template/variants/counter/tests/Counter.spec.ts

@@ -0,0 +1,93 @@
+import { Blockchain } from '@ton-community/sandbox';
+import { Cell, toNano } from 'ton-core';
+import { Counter } from '../wrappers/Counter';
+import '@ton-community/test-utils';
+import { compile } from '@ton-community/blueprint';
+
+describe('Counter', () => {
+    let code: Cell;
+
+    beforeAll(async () => {
+        code = await compile('Counter');
+    });
+
+    it('should deploy', async () => {
+        const blockchain = await Blockchain.create();
+
+        const counter = blockchain.openContract(
+            await Counter.createFromConfig(
+                {
+                    id: 0,
+                    counter: 0,
+                },
+                code
+            )
+        );
+
+        const deployer = await blockchain.treasury('deployer');
+
+        const deployResult = await counter.sendDeploy(deployer.getSender(), toNano('0.05'));
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: deployer.address,
+            to: counter.address,
+            deploy: true,
+        });
+    });
+
+    it('should increase counter', async () => {
+        const blockchain = await Blockchain.create();
+
+        const counter = blockchain.openContract(
+            await Counter.createFromConfig(
+                {
+                    id: 0,
+                    counter: 0,
+                },
+                code
+            )
+        );
+
+        const deployer = await blockchain.treasury('deployer');
+
+        const deployResult = await counter.sendDeploy(deployer.getSender(), toNano('0.05'));
+
+        expect(deployResult.transactions).toHaveTransaction({
+            from: deployer.address,
+            to: counter.address,
+            deploy: true,
+        });
+
+        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 counter.getCounter();
+
+            console.log('counter before increasing', counterBefore);
+
+            const increaseBy = Math.floor(Math.random() * 100);
+
+            console.log('increasing by', increaseBy);
+
+            const increaseResult = await counter.sendIncrease(increaser.getSender(), {
+                increaseBy,
+                value: toNano('0.05'),
+            });
+
+            expect(increaseResult.transactions).toHaveTransaction({
+                from: increaser.address,
+                to: counter.address,
+                success: true,
+            });
+
+            const counterAfter = await counter.getCounter();
+
+            console.log('counter after increasing', counterAfter);
+
+            expect(counterAfter).toBe(counterBefore + increaseBy);
+        }
+    });
+});

package/dist/template/variants/counter/wrappers/Counter.compile.ts

@@ -0,0 +1,5 @@
+import { CompilerConfig } from '@ton-community/blueprint';
+
+export const compile: CompilerConfig = {
+    targets: ['contracts/counter.fc'],
+};

package/dist/template/variants/counter/wrappers/Counter.ts

@@ -0,0 +1,66 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from 'ton-core';
+
+export type CounterConfig = {
+    id: number;
+    counter: number;
+};
+
+export function counterConfigToCell(config: CounterConfig): Cell {
+    return beginCell().storeUint(config.id, 32).storeUint(config.counter, 32).endCell();
+}
+
+export const Opcodes = {
+    increase: 0x7e8764ef,
+};
+
+export class Counter implements Contract {
+    constructor(readonly address: Address, readonly init?: { code: Cell; data: Cell }) {}
+
+    static createFromAddress(address: Address) {
+        return new Counter(address);
+    }
+
+    static createFromConfig(config: CounterConfig, code: Cell, workchain = 0) {
+        const data = counterConfigToCell(config);
+        const init = { code, data };
+        return new Counter(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATLY,
+            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_SEPARATLY,
+            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();
+    }
+}