Truffle is primarily designed for Ethereum smart contract development and supports several programming languages. The main languages used within the Truffle framework are:

1. Solidity

Solidity is the primary programming language for writing smart contracts on the Ethereum blockchain. It is a statically typed language that is similar to JavaScript in its syntax, making it relatively easy to learn for developers familiar with web development.

Here’s a simple example of a smart contract written in Solidity:

// contracts/SimpleStorage.sol
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

2. JavaScript

JavaScript is used extensively in Truffle for testing and deploying smart contracts. Developers can write test cases in JavaScript using the Mocha testing framework and Chai assertion library.

Here’s an example of a test case written in JavaScript for the SimpleStorage contract:

// test/SimpleStorage.test.js
const SimpleStorage = artifacts.require("SimpleStorage");

contract("SimpleStorage", accounts => {
    it("should store the value 89", async () => {
        const simpleStorageInstance = await SimpleStorage.deployed();
        
        // Set value
        await simpleStorageInstance.set(89);
        
        // Get value
        const storedData = await simpleStorageInstance.get();
        assert.equal(storedData, 89, "The value 89 was not stored.");
    });
});

3. JSON (JavaScript Object Notation)

JSON is not a programming language per se, but it is used extensively in Truffle for configuration files. The truffle-config.js file, which contains network configurations and other settings, is written in JavaScript Object Notation.

Here’s an example of a simple Truffle configuration file:

module.exports = {
    networks: {
        development: {
            host: "127.0.0.1",
            port: 7545,
            network_id: "*"
        }
    },
    compilers: {
        solc: {
            version: "0.8.0"
        }
    }
};

4. TypeScript

While not natively supported, TypeScript can also be used with Truffle. Developers can write their tests and scripts in TypeScript, but they will need to set up a TypeScript compiler to transpile the code to JavaScript before running it.

Here’s an example of a test case written in TypeScript:

// test/SimpleStorage.test.ts
import { artifacts, contract, assert } from "truffle";

const SimpleStorage = artifacts.require("SimpleStorage");

contract("SimpleStorage", accounts => {
    it("should store the value 89", async () => {
        const simpleStorageInstance = await SimpleStorage.deployed();
        
        // Set value
        await simpleStorageInstance.set(89);
        
        // Get value
        const storedData = await simpleStorageInstance.get();
        assert.equal(storedData.toString(), "89", "The value 89 was not stored.");
    });
});

Conclusion

In summary, Truffle primarily supports Solidity , JavaScript, JSON, and can also accommodate TypeScript with some additional setup. This versatility allows developers to leverage their existing skills and choose the language that best fits their project needs, making Truffle a flexible choice for Ethereum development.