How to Compile Ethereum Smart Contracts

node --version
v16.0.0 // Your version does not need to match mine

mkdir ProjectName // Make a new project directory
cd ProjectName // Go into our new project directory
npm init // Initialize our project and skip through all of the prompts

npm install --save solc // Installs the solidity compiler and saves it to our package.json

ProjectName/
    ethereum/
        contracts/
            ContractName.sol
        compile.js

First create the ethereum and contracts directory. Then create your Solidity contract file in the contracts folder, or move it there if you have a pre-existing contract you want compiled. If you are still learning Solidity and do not have any contracts of your own you can simply copy mine below for use in this tutorial.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Greeting
 * @dev Store & retrieve string in a variable
 * @author mattauer@umich.edu
 */
contract Greeting {

    string greeting;

    /**
     * @dev Store string in variable
     * @param _greeting value to store
     */
    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }

    /**
     * @dev Return value 
     * @return value of 'greeting'
     */
    function getGreeting() public view returns (string memory){
        return greeting;
    }
}

After adding your contract to the contracts directory, create the compile.js script in the ethereum directory.

Compile Script

Our compile script will compile our Solidity contracts into JSON files so that we can interact with them using javascript. Our first step in writing this script is to require the necessary depenedencies.

const path = require('path'); // Provides utilities for working with file and directory paths
const fs = require('fs-extra'); // Enables interacting with the file system
const solc = require('solc'); // Compiles Solidity code

Next we are going resolve the directory path where we are going to store our compiled JSON contract.

const buildPath = path.resolve(__dirname, 'build');

fs.removeSync(buildPath);

const contractFolder = 'contracts';
const contractName = 'Greeting.sol';
const contractPath = path.resolve(__dirname, contractFolder, contractName);

After we resolve the path to our Solidity contract file, we read in the file and then construct an object to give as input to the Solidity compiler.

// Read in the Solidity contract file
const sourceCode = fs.readFileSync(contractPath, 'utf-8');
// Construct object to give as input to the Solidity compiler
const input = {
    language: "Solidity",
    sources: {
        [contractName]: {
            content: sourceCode,
        },
    },
    settings: {
        outputSelection: {
            "*": {
                "*": ["*"],
            },
        },
    },
};

const outputContracts = JSON.parse(solc.compile(JSON.stringify(input))).contracts[contractName];

// Create build folder if it does not already exist
fs.ensureDirSync(buildPath);

for (let contract in output) {
    fs.outputJSONSync(
        path.resolve(buildPath, `${contract}.json`),
        output[contract]
    );
}

The first part of this code creates the build folder if it does not already exist. The second part of our code loops through the contracts stored in our output object and creates a corresponding compiled contract JSON file in our build directory. Notice how we loop through our output object even though it only contains one contract. We do this because there are many cases in which we store multiple contracts in one .sol file and we want to ensure our compile script is robust enough to handle these instances.

Here is the entire code for compile.js

// Compiles Contracts and outputs them to a json abi
const path = require('path'); // Provides utilities for working with file and directory paths
const fs = require('fs-extra'); // Enables interacting with the file system
const solc = require('solc'); // Compiles solidity code

const buildPath = path.resolve(__dirname, 'build');
// Whenever we compile/recompile remove the abis
fs.removeSync(buildPath);


const contractFolder = 'contracts';
const contractName = 'BattleHandler.sol';
const contractPath = path.resolve(__dirname, contractFolder, contractName);

// Read in the solidity contract file
const sourceCode = fs.readFileSync(contractPath, 'utf-8');
// Construct object to give as input to the solidity compiler
const input = {
    language: "Solidity",
    sources: {
        [contractName]: {
            content: sourceCode,
        },
    },
    settings: {
        outputSelection: {
            "*": {
                "*": ["*"],
            },
        },
    },
};

const output = JSON.parse(solc.compile(JSON.stringify(input))).contracts[contractName];

// Create build folder if it does not already exist
fs.ensureDirSync(buildPath);

for (let contract in output) {
    fs.outputJSONSync(
        path.resolve(buildPath, `${contract}.json`),
        output[contract]
    );
}

Now we can compile our contract from our project directory.

node ethereum/compile.js

If all goes well you should see the newly created JSON file in our build directory.