Deploying Contracts

Different ways to deploy your contracts to Mantle Network

2023/12/04 Thirdweb released a report about recent security vulnerabilities in the commonly used open-source library for web3 smart contracts. All developers who have previously deployed contracts are advised to ensure that the contract is secure, see details here.

Using Remix IDE

Remix‘s web-based IDE supports writing, testing, debugging, and deploying smart contracts written in Solidity, Yul, and other popular contract development languages.

1. Start by opening Remix in your browser. Create a new .sol file under the "Contracts" folder and start writing your code.

2. Once ready, you can proceed with compiling the contract by either clicking the button on the top, or clicking on the blue button that says "Compile <file_name>", which you can access by navigating to the "Solidity Compiler" tab by clicking on the button.

The JSON file containing the bytecode generated upon compiling your contract can be found in the "build-info" directory.

3. If the compilation was successful (shown as in the navigation bar), you'll be able to deploy the contract from the "Deploy and Run Transactions" tab, which can be accessed by clicking on the button. Switch to Mantle Network in your MetaMask wallet and select "Injected Provider - MetaMask" from the "Environment" dropdown list and select a wallet account that will be used to pay the gas fees. Remix will automatically connect to network that the wallet is currently connected to. Click on the button to send the deploy transaction.

In case you haven't added Mantle Network to your wallet yet, click on the icon next to the "Environment" label. This will take you to Chainlist's website where you can look up Mantle Mainnet and Testnet settings and add them to your wallet.

Upon successful deployment, you'll be able to see the transaction and contract info in the terminal at the bottom, like so:

Using Hardhat

Hardhat is a smart contract development environment that comes with tools that can be used to compile, debug, and deploying Solidity smart contracts and dApps on Ethereum and other EVM-compatible chains like Mantle Network.

1. Start by creating a new Hardhat project and configuring the hardhat.config.js file to add Mantle Network's settings to it.

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from 'dotenv';

dotenv.config();

const config: HardhatUserConfig = {
    solidity: "0.8.19", // solidity version
    defaultNetwork: "mantleTest", // chosen by default when network isn't specified while running Hardhat
    networks: {
        mantle: {
        url: "https://rpc.mantle.xyz", //mainnet
        accounts: [process.env.ACCOUNT_PRIVATE_KEY ?? ''],
        },
        mantleTest: {
        url: "https://rpc.testnet.mantle.xyz", // testnet
        accounts: [process.env.ACCOUNT_PRIVATE_KEY ?? '']
        }
    },
    etherscan: {
        apiKey: process.env.API_KEY,
    },
};

export default config;

2. With your contracts ready in the "Contracts" directory within your Hardhat project, you can run the following command to compile them.

npx hardhat compile
Compiling...
Compiled 1 contract successfully

3. Use the following command to deploy your contracts to a chosen network.

npx hardhat run --network mantleTest scripts/deploy.ts
Contract deployed to address: 0x0000000000000000000000000000000000000000

Refer to the Troubleshooting page if you run into issues while deploying your contract.

Using Foundry

Foundry is a fast, portable and modular toolkit for EVM application development written in Rust. The two main components that you'll generally be using for smart contract development are:

• Forge: used to compile, test, and deploy contracts

• Cast: used to make RPC calls to interact with a network

1. Use the following command to compile a smart contract.

forge build

Sample Output

[⠊] Compiling...
[⠑] Installing solc version 0.8.21
[⠰] Successfully installed solc 0.8.21
[⠒] Compiling 22 files with 0.8.21
[⠃] Solc 0.8.21 finished in 3.19s
Compiler run successful!

2. Upon successful compilation, use the following command to deploy a smart contract

forge create --rpc-url https://rpc.testnet.mantle.xyz --private-key <your-private-key> src/Storage.sol:Storage --legacy 

Sample Output

[⠢] Compiling...
No files changed, compilation skipped
Deployer: 0x...
Deployed to: 0x...
Transaction hash: 0x...

Using Thirdweb CLI

You can install the thirdweb CLI globally on your machine using npm by running the following command.

npm i -g @thirdweb-dev/cli

Creating a Project

1. Start by creating a new project by running:

npx thirdweb create contract

2. Input your preferences for the command line prompts:

   1. Give your project a name

   2. Choose your preferred framework: Hardhat or Foundry

   3. Name your smart contract

   4. Choose the type of base contract: Empty, ERC20, ERC721, or ERC1155

   5. Add any desired extensions

3. Once created, navigate to your project’s directory and open in your preferred code editor. If you open the contracts folder, you will find your smart contract; this is your smart contract written in Solidity.

4. The following is code for an ERC721Base contract without specified extensions. It implements all of the logic inside the ERC721Base.sol contract; which implements the ERC721A standard.

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

import "@thirdweb-dev/contracts/base/ERC721Base.sol";

contract Contract is ERC721Base {
    constructor(
        string memory _name,
        string memory _symbol,
        address _royaltyRecipient,
        uint128 _royaltyBps
    ) ERC721Base(_name, _symbol, _royaltyRecipient, _royaltyBps) {}
}

This contract inherits the functionality of ERC721Base through the following steps:

• Importing the ERC721Base contract

• Inheriting the contract by declaring that our contract is an ERC721Base contract

• Implementing any required methods, such as the constructor.

5. After modifying your contract with your desired custom logic, you're ready to deploy it to Mantle using Deploy.

You can also navigate to the thirdweb Explore page and choose from a collection of pre-built contracts to use and deploy. For more information on different contracts available on Explore, check out thirdweb’s documentation.

Deploying Contract

deploy allows you to deploy a smart contract to Mantle Network without configuring RPC URLs, exposing your private keys, writing scripts, and other additional setup such as verifying your contract.

1. To deploy your smart contract using deploy, navigate to the root directory of your project and run:

npx thirdweb deploy

Executing this command will trigger the following actions:

• Compiling all the contracts in the current directory.

• Providing the option to select which contract(s) you wish to deploy.

• Uploading your contract source code (ABI) to IPFS.

2. When it is completed, it will open a dashboard interface to finish filling out the parameters for our contract.

   • _name: contract name

   • _symbol: symbol or "ticker"

   • _royaltyRecipient: wallet address to receive royalties from secondary sales

   • _royaltyBps: basis points (bps) that will be given to the royalty recipient for each secondary sale, e.g. 500 = 5%

3. Select Mantle Testnet as the network if you're deploying to the testnet, or Mantle Mainnet if you're deploying to production.

4. Manage additional settings on your contract’s dashboard as needed such as uploading NFTs, configuring permissions, and more.

For additional information on deploy, refer to thirdweb’s documentation. You can reach out thirdweb support at http://support.thirdweb.com/.