tact flow

Author: aigerimu

docs/v3/guidelines/quick-start/developing-smart-contracts/func-tolk-folder/deploying-to-network.mdx

@@ -57,6 +57,7 @@ Now that our smart contracts are fully tested, we are ready to deploy them to TO
 Deployment scripts rely on the same wrappers that you have used in testing scripts. We will use one common script to deploy both of the previously deployed smart contracts. Update `deployHelloWorld.ts` with this code:
 
 ```typescript title="/scripts/deployHelloWorld.ts"
+@version TypeScript 5.8.3
 import { toNano } from '@ton/core';
 import { HelloWorld } from '../wrappers/HelloWorld';
 import { compile, NetworkProvider } from '@ton/blueprint';

docs/v3/guidelines/quick-start/developing-smart-contracts/func-tolk-folder/processing-messages.mdx

@@ -311,6 +311,7 @@ async sendExternalIncrease(
 Update the test to ensure that the `HelloWorld` contract received the external message, and updated its counters:
 
 ```typescript title="/tests/HelloWorld.spec.ts"
+@version TypeScript 5.8.3
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
 import { Cell, toNano} from '@ton/core';
 import { HelloWorld } from '../wrappers/HelloWorld';

docs/v3/guidelines/quick-start/developing-smart-contracts/func-tolk-folder/storage-and-get-methods.mdx

@@ -408,6 +408,7 @@ Next, we'll update our wrapper class to align with the new storage layout and `g
 These changes will maintain consistency with our smart contract modifications.
 
 ```typescript title="/wrappers/HelloWorld.ts"
+@version TypeScript 5.8.3
 export type HelloWorldConfig = {
     id: number;
     ctxCounter: number;
@@ -446,6 +447,7 @@ Finally, let's test the new functionality using our updated wrapper:
 Example implementation:
 
 ```typescript title="/tests/HelloWorld.spec.ts"
+@version TypeScript 5.8.3
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
 import { Cell, toNano} from '@ton/core';
 import { HelloWorld } from '../wrappers/HelloWorld';

docs/v3/guidelines/quick-start/developing-smart-contracts/tact-folder/tact-blueprint-sdk-overview.mdx

@@ -15,13 +15,11 @@ If you didn't choose the proposed names in the previous steps, source code file
 :::
 
 <Tabs groupId="language">
-  <TabItem value="FunC" label="FunC">
+  <TabItem value="Tact" label="Tact">
     ```ls title="Project structure"
     Example/
     ├── contracts/           # Folder containing smart contracts code
-    │   ├── imports/         # Library imports for contracts
-    │   │   └── stdlib.fc    # Standard library for FunC
-    │   └── hello_world.fc   # Main contract file
+    │   ├── hello_world.tact   # Main contract file
     ├── scripts/             # Deployment and on-chain interaction scripts
     │   ├── deployHelloWorld.ts     # Script to deploy the contract
     │   └── incrementHelloWorld.ts  # Script to interact with the contract
@@ -32,21 +30,7 @@ If you didn't choose the proposed names in the previous steps, source code file
     └── HelloWorld.compile.ts   # Script for contract compilation
     ```
   </TabItem>
-  <TabItem value="Tolk" label="Tolk">
-    ```ls title="Project structure"
-    Example/
-    ├── contracts/           # Folder containing smart contracts code
-    │   └── hello_world.tolk # Main contract file
-    ├── scripts/             # Deployment and on-chain interaction scripts
-    │   ├── deployHelloWorld.ts     # Script to deploy the contract
-    │   └── incrementHelloWorld.ts  # Script to interact with the contract
-    ├── tests/               # Test fo der for local contract testing
-    │   └── HelloWorld.spec.ts      # Test specifications for the contract
-    └── wrappers/            # TypeScript wrappers for contract interaction
-    ├── HelloWorld.ts           # Wrapper class for smart contract
-    └── HelloWorld.compile.ts   # Script for contract compilation
-    ```
-  </TabItem>
+
 </Tabs>
 
 ### `/contracts`

docs/v3/guidelines/quick-start/developing-smart-contracts/tact-folder/tact-deploying-to-network.mdx

@@ -59,42 +59,27 @@ Deployment scripts rely on the same wrappers that you have used in testing scrip
 ```typescript title="/scripts/deployHelloWorld.ts"
 import { toNano } from '@ton/core';
 import { HelloWorld } from '../wrappers/HelloWorld';
-import { CounterInternal } from '../wrappers/CounterInternal';
 import { compile, NetworkProvider } from '@ton/blueprint';
 
 export async function run(provider: NetworkProvider) {
-    const helloWorld = provider.open(
-        HelloWorld.createFromConfig(
-            {
-                id: Math.floor(Math.random() * 10000),
-                ctxCounter: 0,
-                ctxCounterExt: 0n,
-            },
-            await compile('HelloWorld')
-        )
-    );
+    const sender = provider.sender();
+    if (!sender.address) {
+        throw new Error('Sender address is required');
+    }
 
-    await helloWorld.sendDeploy(provider.sender(), toNano('0.05'));
-
-    await provider.waitForDeploy(helloWorld.address);
-
-    const counterInternal = provider.open(
-        await CounterInternal.fromInit(
-            BigInt(Math.floor(Math.random() * 10000)),
-            helloWorld.address
-        )
+    const helloWorld = provider.open(
+        await HelloWorld.fromInit(0n, sender.address)
     );
 
-    await counterInternal.send(
-        provider.sender(),
+    await helloWorld.send(
+        sender,
         { value: toNano('0.05') },
         null
     );
 
-    await provider.waitForDeploy(counterInternal.address);
+    await provider.waitForDeploy(helloWorld.address);
 
-    console.log('ID', await helloWorld.getID());
-    console.log('ID', (await counterInternal.getId()).toString());
+    console.log('ID', await helloWorld.getId());
 }
 ```
 

docs/v3/guidelines/quick-start/developing-smart-contracts/tact-folder/tact-storage-and-get-methods.mdx

@@ -60,7 +60,7 @@ Using this structure, a message can be sent to the contract from FunC.
 The [contract](https://docs.tact-lang.org/book/contracts/) definition in Tact follows an object-oriented programming style:
 
 ```tact
-contract CounterInternal {
+contract HelloWorld {
     ...
 }
 ```
@@ -76,7 +76,7 @@ counter: Int as uint32;
 
 To ensure that only the contract owner can interact with specific functions, add an `owner` field:
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 id: Int as uint32;
 counter: Int as uint32;
 owner: Address;
@@ -88,7 +88,7 @@ These fields are serialized similarly to structures and stored in the contract's
 
 If you compile the contract at this stage, you will encounter the error: `Field "owner" is not set`. This is because the contract needs to initialize its fields upon deployment. Define an [`init()`](https://docs.tact-lang.org/book/contracts/#init-function/) function to do this:
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 init(id: Int, owner: Address) {
     self.id = id;
     self.counter = 0;
@@ -100,7 +100,7 @@ init(id: Int, owner: Address) {
 
 To accept messages from other contracts, use a [receiver](https://docs.tact-lang.org/book/functions/#receiver-functions) function. Receiver functions automatically match the message's opcode and invoke the corresponding function:
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 receive(msg: Add) {
     self.counter += msg.amount;
     self.notify("Cashback".asComment());
@@ -109,7 +109,7 @@ receive(msg: Add) {
 
 For accepting messages with empty body you can add `recieve` function with no arguments:
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 receive() {
     cashback(sender())
 }
@@ -120,7 +120,7 @@ receive() {
 
 Tact also provides handy ways to share same logic through [traits](https://docs.tact-lang.org/book/types/#traits). To ensure that only the contract owner can send messages, use the `Ownable` trait, which provides built-in ownership checks:
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 // Import library to use trait
 import "@stdlib/ownable";
 
@@ -149,7 +149,7 @@ Tact supports [getter functions](https://docs.tact-lang.org/book/functions/#gett
 Get function cannot be called from another contract.
 :::
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 get fun counter(): Int {
     return self.counter;
 }
@@ -159,7 +159,7 @@ Note, that the `owner` getter is automatically defined via the `Ownable` trait.
 
 #### Complete contract
 
-```tact title="/contracts/counter_internal.tact"
+```tact title="/contracts/hello_world.tact"
 import "@stdlib/ownable";
 
 // message with opcode
@@ -169,7 +169,7 @@ message(0x7e8764ef) Add {
 }
 
 // Contract defenition. `Ownable` is a trait to share functionality.
-contract CounterInternal with Ownable {
+contract HelloWorld with Ownable {
 
     // storage variables
     id: Int as uint32;
@@ -233,7 +233,7 @@ Expected output should look like this:
 
 [Wrappers](https://docs.tact-lang.org/book/compile/#wrap-ts) facilitate contract interaction from TypeScript. Unlike in FunC or Tolk, they are generated automatically during the build process:
 
-```typescript title="/wrappers/CounterInternal.ts"
+```typescript title="/wrappers/HelloWorld.ts"
 export * from '../build/CounterInternal/tact_CounterInternal';
 ```
 
@@ -246,15 +246,15 @@ Now let's ensure that our smart contract code fails when we try to send `add` me
 
 Implementation of test should look like this:
 
-```typescript title="/tests/CounterInternal.spec.ts"
+```typescript title="/tests/HelloWorld.spec.ts"
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox';
 import { toNano } from '@ton/core';
-import { CounterInternal } from '../wrappers/CounterInternal';
+import { HelloWorld } from '../wrappers/HelloWorld';
 import '@ton/test-utils';
 
-describe('CounterInternal Basic Tests', () => {
+describe('HelloWorld Basic Tests', () => {
     let blockchain: Blockchain;
-    let counterInternal: SandboxContract<CounterInternal>;
+    let helloWorld: SandboxContract<HelloWorld >;
     let owner: SandboxContract<TreasuryContract>;
 
     beforeEach(async () => {
@@ -265,12 +265,12 @@ describe('CounterInternal Basic Tests', () => {
         owner = await blockchain.treasury('owner');
 
         // Deploy the contract
-        counterInternal = blockchain.openContract(
-            await CounterInternal.fromInit(0n, owner.address)
+        helloWorld = blockchain.openContract(
+            await HelloWorld .fromInit(0n, owner.address)
         );
 
         // Send deploy transaction
-        const deployResult = await counterInternal.send(
+        const deployResult = await helloWorld.send(
             owner.getSender(),
             { value: toNano('1.00') },
             null
@@ -279,29 +279,29 @@ describe('CounterInternal Basic Tests', () => {
         // Verify deployment was successful
         expect(deployResult.transactions).toHaveTransaction({
             from: owner.address,
-            to: counterInternal.address,
+            to: helloWorld.address,
             deploy: true,
             success: true
         });
     });
 
     it('should initialize with correct values', async () => {
         // Check initial counter value
-        const initialCounter = await counterInternal.getCounter();
+        const initialCounter = await helloWorld.getCounter();
         expect(initialCounter).toBe(0n);
 
         // Check initial ID
-        const id = await counterInternal.getId();
+        const id = await helloWorld.getId();
         expect(id).toBe(0n);
     });
 
     it('should allow owner to increment counter', async () => {
         // Get initial counter value
-        const initialCounter = await counterInternal.getCounter();
+        const initialCounter = await helloWorld.getCounter();
 
         // Increment counter by 5
         const incrementAmount = 5n;
-        const result = await counterInternal.send(
+        const result = await helloWorld.send(
             owner.getSender(),
             { value: toNano('0.05') },
             {
@@ -314,12 +314,12 @@ describe('CounterInternal Basic Tests', () => {
         // Verify transaction was successful
         expect(result.transactions).toHaveTransaction({
             from: owner.address,
-            to: counterInternal.address,
+            to: helloWorld.address,
             success: true
         });
 
         // Check counter was incremented correctly
-        const newCounter = await counterInternal.getCounter();
+        const newCounter = await helloWorld.getCounter();
         expect(newCounter).toBe(initialCounter + incrementAmount);
     });
 
@@ -328,10 +328,10 @@ describe('CounterInternal Basic Tests', () => {
         const nonOwner = await blockchain.treasury('nonOwner');
 
         // Get initial counter value
-        const initialCounter = await counterInternal.getCounter();
+        const initialCounter = await helloWorld.getCounter();
 
         // Try to increment counter as non-owner
-        const result = await counterInternal.send(
+        const result = await helloWorld.send(
             nonOwner.getSender(),
             { value: toNano('0.05') },
             {
@@ -344,12 +344,12 @@ describe('CounterInternal Basic Tests', () => {
         // Verify transaction failed
         expect(result.transactions).toHaveTransaction({
             from: nonOwner.address,
-            to: counterInternal.address,
+            to: helloWorld.address,
             success: false
         });
 
         // Verify counter was not changed
-        const newCounter = await counterInternal.getCounter();
+        const newCounter = await helloWorld.getCounter();
         expect(newCounter).toBe(initialCounter);
     });
 
@@ -359,7 +359,7 @@ describe('CounterInternal Basic Tests', () => {
         let expectedCounter = 0n;
 
         for (const amount of increments) {
-            await counterInternal.send(
+            await helloWorld.send(
                 owner.getSender(),
                 { value: toNano('0.05') },
                 {
@@ -372,11 +372,12 @@ describe('CounterInternal Basic Tests', () => {
         }
 
         // Verify final counter value
-        const finalCounter = await counterInternal.getCounter();
+        const finalCounter = await helloWorld.getCounter();
         expect(finalCounter).toBe(expectedCounter);
     });
 });
 
+
 ```
 
 Don't forget to verify the example is correct by running test script:
@@ -389,8 +390,8 @@ Expected output should look like this:
 
 ```bash
 
- PASS  tests/CounterInternal.spec.ts
-  CounterInternal Basic Tests
+ PASS  tests/HelloWorld.spec.ts
+  HelloWorld Basic Tests
     ✓ should initialize with correct values (211 ms)
     ✓ should allow owner to increment counter (100 ms)
     ✓ should prevent non-owner from incrementing counter (152 ms)