# Using Truffle

Here is a detailed explanation of what Truffle is and a step-by-step guide on how to deploy a TEP1155 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 TEP1155 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 TEP1155Project
cd TEP1155Project
```

**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 TEP1155NFT`.sol` in the `contracts` directory and add your TEP1155NFT code:

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

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

contract TEP1155NFT is ERC1155, Ownable {
    constructor(address initialOwner) ERC1155("") Ownable(initialOwner) {}

    function mint(address account, uint256 id, uint256 amount, bytes memory data)
        public
        onlyOwner
    {
        _mint(account, id, amount, data);
    }

    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
        public
        onlyOwner
    {
        _mintBatch(to, ids, amounts, data);
    }
}
```

## 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 TEP1155NFT = artifacts.require("TEP1155NFT");

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

## 6.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,"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
```

***Congratulations!!*** You have successfully deployed your TEP1155 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-1155/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.