# Using Truffle

Here is a detailed explanation of what Truffle is and a step-by-step guide on how to deploy a TEP20 contract using truffle:|

## What is Truffle ?

Truffle is a development framework for Ethereum and Ethereum-compatible blockchains such as TAN-chain. It provides a suite of tools for smart contract development, including a built-in compiler, a testing framework, and scripts to deploy contracts.

## Step-by-Step Guide to Deploy Contract

Follow these steps to deploy a TEP20 contract using Truffle:

## 1. Install Truffle

Ensure you have Node.js and npm installed. Then, install Truffle globally:

```
npm install -g truffle
```

## 2. Initialize Truffle Project

**Create a new directory for your project**:

```
mkdir TEP20TokenProject
```

```
cd TEP20TokenProject
```

**Initialize the project with Truffle**:

```
truffle init
```

This command creates a basic Truffle project structure with the following directories:

* `contracts`: Where your smart contracts go.
* `migrations`: Where deployment scripts go.
* `test`: Where your test scripts go.

## 3. Write the Contract

Create a new file `TEP20Token.sol` in the `contracts` directory and add your TEP20 token code:

```
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract TEP20Token is ERC20, Ownable {
    constructor()
        ERC20("MyToken", "MTK")
        Ownable(msg.sender)
    {}

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}
```

## 4. Compile the Contract

Run the following command to compile your contract:

```
truffle compile
```

This command compiles the contracts in the `contracts` directory and generates the necessary artifacts in the `build/contracts` directory.

## 5. Write the Deployment Script

Create a new file 1`_deploy_contracts.js` in the `migrations` directory and add the following content:

```
const TEP20Token = artifacts.require("TEP20Token");

module.exports = function(deployer) {
  deployer.deploy(TEP20Token);
};
```

## Configure the Network

**Install `truffle-hdwallet-provider` and `dotenv`**:

```
npm install truffle-hdwallet-provider dotenv
```

**Create a \``` .env` `` file** in the root of your project directory to store your private key.

```
// In .env file

YOUR_PRIVATE_KEY = "YOUR_PRIVATE_KEY"

```

Update the `truffle-config.js` file to include the Taral-chain network configuration. For example:

```

const HDWalletProvider = require("truffle-hdwallet-provider");
require("dotenv").config();

const mnemonic = process.env.YOUR_PRIVATE_KEY;

module.exports = {

  networks: {
    
    taral: {
      provider: () => new HDWalletProvider(mnemonic,"https://devnet-rpc1.tanledger.com"),
      network_id: 4442,
      chainId:4442
    }
   
  },

  mocha: {
    // timeout: 100000
  },

  // Configure your compilers
  compilers: {
    solc: {
      version: "0.8.20", // Fetch exact version from solc-bin (default: truffle's version)
   
    }
  },
};
```

## 7.Deploy the Contract

Run the following command to deploy the contract to the specified network:

```
truffle migrate --network tan
```

After a successful deployment, you should see an output similar to this:

<figure><img src="/files/eIWKfqrBbbHsSzoeNrqf" alt=""><figcaption></figcaption></figure>

***Congratulations!!*** You have successfully deployed your TEP20 token contract on the TAN-chain network using Truffle. This guide covered the entire process from setting up the Truffle project to deploying the contract.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tan.live/getting-started/developer-guide/deploy-smart-contracts/tep-20/using-truffle.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.