Contract Lifecycle

This guide covers the complete lifecycle of a smart contract on TetraChain: from development to deployment and interaction.

Prerequisites

Complete Setting Up Your Environment before proceeding.

Overview

The contract development cycle consists of five stages:

1. Development — Write contract code in FunC

2. Build — Compile to TVM bytecode

3. Test — Validate behavior in sandbox

4. Deploy — Publish to TetraChain network

5. Interact — Execute contract methods

1. Development

Create a Contract

Generate a new contract using Blueprint:

npx blueprint create SimpleCounter

Select contract type:

• Empty contract — Minimal template

• Counter — Simple state management example

For this guide, select "Counter" — it provides a working example with state management that we'll use throughout the tutorial.

Contract Structure

Blueprint generates three files:

contracts/SimpleCounter.fc     # FunC source code
wrappers/SimpleCounter.ts      # TypeScript wrapper
tests/SimpleCounter.spec.ts    # Test suite

2. Build

Compile Contract

npx blueprint build

Output:

Build script running, compiling SimpleCounter
🔧 Using func version 0.4.6...

✓ Compiled successfully!
✓ Wrote compilation artifact to build/SimpleCounter.compiled.json

Build Artifacts

Compiled files are stored in build/:

build/
├── SimpleCounter.compiled.json  # Bytecode + metadata
├── SimpleCounter.fif            # Intermediate representation
└── SimpleCounter.pkg            # Package data

3. Test

Configure Test Environment for TetraChain

tests/SimpleCounter.spec.ts:

import { Blockchain, SandboxContract } from '@ton/sandbox';
import { TychoExecutor } from '@tychosdk/emulator';
import { TonApiClient } from '@ton-api/client';
import { Address, toNano } from '@ton/core';
import { SimpleCounter } from '../wrappers/SimpleCounter';
import { compile } from '@ton/blueprint';

describe('SimpleCounter', () => {
    let blockchain: Blockchain;
    let simpleCounter: SandboxContract<SimpleCounter>;

    beforeAll(async () => {
        // Initialize TetraChain
        const tonapi = new TonApiClient({
            baseUrl: 'https://tetra.tonapi.io/',
        });

        const configAccount = await tonapi.blockchain.getBlockchainRawAccount(
            Address.parse('-1:5555555555555555555555555555555555555555555555555555555555555555'),
        );

        const config = configAccount.data!.asSlice().loadRef();

        blockchain = await Blockchain.create({
            executor: await TychoExecutor.create(),
            config,
        });
    });

    beforeEach(async () => {
        simpleCounter = blockchain.openContract(
            SimpleCounter.createFromConfig(
                {
                    id: 0,
                    counter: 0
                },
                await compile('SimpleCounter')
            )
        );

        const deployer = await blockchain.treasury('deployer');
        await simpleCounter.sendDeploy(deployer.getSender(), toNano('0.05'));
    });

    it('should deploy', async () => {
        const counter = await simpleCounter.getCounter();
        expect(counter).toBe(0);
    });

    it('should increase counter', async () => {
        const sender = await blockchain.treasury('sender');
        
        await simpleCounter.sendIncrease(sender.getSender(), {
            value: toNano('0.05'),
            increaseBy: 5,
        });

        expect(await simpleCounter.getCounter()).toBe(5);
    });

    it('should increase multiple times', async () => {
        const sender = await blockchain.treasury('sender');
        
        await simpleCounter.sendIncrease(sender.getSender(), {
            value: toNano('0.05'),
            increaseBy: 3,
        });

        await simpleCounter.sendIncrease(sender.getSender(), {
            value: toNano('0.05'),
            increaseBy: 7,
        });

        expect(await simpleCounter.getCounter()).toBe(15);
    });
});

Run Tests

npx blueprint test

Output:

  PASS  tests/SimpleCounter.spec.ts
  SimpleCounter
    ✓ should deploy (300 ms)
    ✓ should increase counter (142 ms)
    ✓ should increase multiple times (189 ms)

Tests: 3 passed, 3 total

4. Deploy

Create Deployment Script

scripts/deploySimpleCounter.ts:

import { toNano } from '@ton/core';
import { SimpleCounter } from '../wrappers/SimpleCounter';
import { compile, NetworkProvider } from '@ton/blueprint';

export async function run(provider: NetworkProvider) {
    const simpleCounter = provider.open(
        SimpleCounter.createFromConfig(
            {
                id: Math.floor(Math.random() * 10000),
                counter: 0,
            },
            await compile('SimpleCounter')
        )
    );

    await simpleCounter.sendDeploy(provider.sender(), toNano('0.05'));
    await provider.waitForDeploy(simpleCounter.address);
    console.log('ID', await simpleCounter.getID());
}

Execute Deployment

npx blueprint run

Blueprint will prompt you to:

1. Select a script: Choose deploySimpleCounter

2. Choose a wallet: Select your deployment wallet

5. Interact

Create Interaction Script

scripts/increaseCounter.ts:

import { Address, toNano } from '@ton/core';
import { SimpleCounter } from '../wrappers/SimpleCounter';
import { NetworkProvider } from '@ton/blueprint';

export async function run(provider: NetworkProvider, args: string[]) {
    const address = Address.parse(args[0]);
    const increaseBy = parseInt(args[1]);

    const simpleCounter = provider.open(SimpleCounter.createFromAddress(address));

    await simpleCounter.sendIncrease(provider.sender(), {
        value: toNano('0.05'),
        increaseBy,
    });

    console.log('Counter increased by', increaseBy);
    console.log('New value:', await simpleCounter.getCounter());
}

Execute Interaction

npx blueprint run increaseCounter EQCx1...xyz 10

Output:

Counter increased by 10
New value: 10

For all details about the Contract Lifecycle, please use the links below

• Blueprint Development Guide

• Setting Up Your Environment

• FunC Language Reference

• TON Sandbox

• Tycho Emulator