This guide will walk you through the process of deploying your Solidity smart contracts to the TAC EVM Layer using Foundry. By the end, you’ll have successfully deployed a contract that can interact with the TON ecosystem through the TON Adapter.

TAC provides a standard EVM environment, allowing you to use modern tools like Foundry for smart contract development and deployment.

​
Prerequisites

Before you begin, make sure you have the following:

  • An Ethereum wallet with private key
  • Basic familiarity with Solidity and smart contract development
  • Some TAC tokens for gas fees (available from the testnet faucet for testing)

​
Step 1: Install Foundry

If you haven’t already installed Foundry, start by setting it up on your system.

1

Install Foundry

curl -L https://foundry.paradigm.xyz | bash

After the installation script completes, run:

foundryup
2

Verify installation

forge --version

You should see version information for forge, cast, and anvil.

​
Step 2: Create a New Foundry Project

1

Initialize a new Foundry project

forge init tac-foundry-demo
cd tac-foundry-demo

This creates a new Foundry project with a basic structure.

2

Explore the project structure

Foundry creates several directories:

  • src/: Directory for your smart contracts
  • test/: Directory for your tests
  • script/: Directory for deployment scripts
  • lib/: Directory for dependencies
  • foundry.toml: Foundry configuration file

​
Step 3: Write a Smart Contract

Let’s create a simple smart contract to deploy to TAC.

1

Create a contract file

Replace the content of src/Counter.sol with our SimpleStorage contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract SimpleStorage {
uint256 private value;
address public owner;

event ValueChanged(uint256 indexed oldValue, uint256 indexed newValue, address by);

constructor() {
    owner = msg.sender;
}

function setValue(uint256 newValue) public {
    uint256 oldValue = value;
    value = newValue;
    emit ValueChanged(oldValue, newValue, msg.sender);
}

function getValue() public view returns (uint256) {
    return value;
}
}
2

Create a deployment script

Create a new file in the script directory:

touch script/DeploySimpleStorage.s.sol

Add the following code to script/DeploySimpleStorage.s.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import "forge-std/Script.sol";
import "../src/Counter.sol";

contract DeploySimpleStorage is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        
        vm.startBroadcast(deployerPrivateKey);
        
        SimpleStorage simpleStorage = new SimpleStorage();
        
        console.log("SimpleStorage deployed to:", address(simpleStorage));
        
        vm.stopBroadcast();
    }
}

​
Step 4: Configure Foundry for TAC

1

Create a .env file for your private key

touch .env

Add your private key to the .env file:

PRIVATE_KEY=your_private_key_here

Never commit your .env file to version control. Add it to your .gitignore file.

2

Update foundry.toml

Update the foundry.toml file to include the TAC network configurations:

[profile.default]
src = 'src'
out = 'out'
libs = ['lib']
solc = "0.8.17"

[rpc_endpoints]
tac_testnet = "https://turin.rpc.tac.build"

[etherscan]
tac_testnet = { key = "" }

​
Step 5: Get Testnet TAC Tokens

Before deploying to the testnet, you’ll need some TAC tokens to pay for gas fees.

1

Add TAC Testnet to your wallet

Add the TAC testnet to your MetaMask or other Ethereum wallet with the following details:

2

Get testnet tokens from the faucet

Visit the TAC Testnet Faucet and follow these steps:

  1. Connect your wallet
  2. Enter your wallet address
  3. Submit the request
  4. Wait for the tokens to arrive in your wallet

​
Step 6: Compile the Contract

1

Compile the contracts

forge build

You should see output indicating successful compilation.

​
Step 7: Deploy the Contract to TAC Testnet

Now, let’s deploy the contract to the TAC testnet.

1

Load environment variables

source .env
2

Deploy the contract

forge script script/DeploySimpleStorage.s.sol --rpc-url tac_testnet --broadcast --verify

If you encounter issues with verification, you can deploy without it:

forge script script/DeploySimpleStorage.s.sol --rpc-url tac_testnet --broadcast

You should see output with the deployment transaction and contract address.

3

Verify the deployment

You can verify your deployment by checking the TAC Turin Explorer:

  1. Visit TAC Turin Explorer
  2. Search for your contract address
  3. Confirm the contract details and transaction history

​
Step 8: Make Your Contract Accessible from TON

To make your contract accessible from TON wallets, you’ll need to create a proxy contract. This is covered in detail in the Build a Proxy Contract guide, but here’s a brief overview:

1

Create a proxy contract

Create a proxy contract that connects to your SimpleStorage contract and handles cross-chain messages from TON.

2

Deploy the proxy contract

Deploy the proxy contract to the TAC EVM Layer using the same Foundry workflow.

3

Connect with frontend

Use the TAC SDK to connect your frontend application to the proxy contract, enabling TON wallet interactions.

​
Next Steps

Congratulations! You’ve successfully deployed a smart contract to the TAC EVM Layer using Foundry. Now you can:

Build a Proxy Contract

Learn how to create a proxy contract that enables TON users to interact with your EVM contract

Integrate with TAC SDK

Discover how to connect your frontend to your deployed contracts using the TAC SDK

Was this page helpful?