Optimism Platform: Developing and Implementing Layer 2 Smart Contracts

---

Due to network congestion and high transaction fees, Layer 2 smart contract development was introduced to enhance scalability and efficiency. Optimism, with its unique technical design, aims to address Ethereum's scalability and fee challenges. It achieves this by maintaining continuous interaction with Ethereum's Layer 1 while processing transactions on its Layer 2 for greater cost-effectiveness and efficiency.

Why use optimism ?

1. It reduces gas transactions during transactions.
2. It processes transactions efficiently.
3. Like a layer 1 smart contract, it offers enhanced security.

You may also like | How to Scale Smart Contracts with State Channels

What is the process by which Optimism functions and manages transactions?

Optimism employs a cutting-edge data compression technique called Optimistic Rollups, a revolutionary method for scaling the Ethereum blockchain developed by the Optimism Foundation. Rollups are categorized into two types: Optimistic Rollups, pioneered by the Optimism Foundation, and Zero-Knowledge Rollups (ZK Rollups).

Optimistic Rollups enhance processing efficiency by offloading a significant portion of transaction data off-chain. Unlike other sidechains, they still publish a small amount of data to Ethereum's Layer 1 network for validation, ensuring robust security.

Unlike ZK Rollups, which publish cryptographic proofs of transaction validity, Optimistic Rollups assume off-chain transactions are valid by default and do not include proofs for on-chain transaction batches. To prevent incorrect state transitions, fraud proofs are employed. These proofs ensure Ethereum Optimism transactions are executed correctly.

At the core of this functionality is the Optimistic Virtual Machine (OVM), which acts as a sandbox environment, ensuring deterministic smart contract execution between Layer 1 and Layer 2. While both the OVM and Ethereum Virtual Machine (EVM) handle computations, the OVM serves as an interface for the EVM.

The Execution Manager facilitates virtualization, enabling seamless comparison between EVM and OVM executions. The Solidity compiler plays a key role, in translating Solidity code into Yul, which is then converted into EVM instructions and compiled into bytecode. Once converted to EVM assembly, each opcode is "rewritten" into its OVM equivalent, ensuring compatibility with the Optimistic Virtual Machine (OVM). 

Also, Explore | Build a Secure Smart Contract Using zk-SNARKs in Solidity

Advantages of Optimiser:

1. Optimism provides faster transaction rates ranging from 200 to 2000 tps compared to Ethereum layer 1 which only manages roughly 10 TPS.
2. All transaction data is securely saved on Ethereum's Layer 1, ensuring that the ecosystem stays decentralized and credible.
3. Optimistic Rollups are entirely Ethereum in sync, providing the same characteristics and features via EVM and Solidity.

Drawbacks of Optimiser:

1. With only 5.85% of its entire supply being in circulation, there is still an immense number of tokens to be produced, which could    have a consequence on the market 
2. Optimism's market capitalization is comparable to that of Polygon, a leading scaling solution, which may convey that the company is now undervalued potentially paving the way for a price correction.

You may also explore | Multi-Level Staking Smart Contract on Ethereum with Solidity

Popular DApps on Optimism Blockchain:

• UniSwap,
• Stargate Finance,
• Sonne Finance,
• 1inch Network,
• Celer Network.

Steps follow to Deploy Smart Contract on optimism :

Setting Up the Environment

1. Install necessary tools:
 

Npm (or yarn) and Node.js: Ensure the most recent versions are installed.
Hardhat: An Ethereum development environment. Use npm to install it globally:
Bash: npm install -g hardhat
 

2. Establish a New Hardhat Project: Start a new one.
Bash: npx hardhat init
3. Configure the Hardhat network:
Modify the hardhat.config.js file to add the testnet setup for Optimism Sepolia:

require('@nomicfoundation/hardhat-toolbox');
module.exports = {
   solidity: '0.8.20',
   networks: {
       opSepolia: {
           url: 'YOUR OP_SOPOLIA TEST_NET RPC',
           accounts: ['YOUR_PRIVATE_KEY'],
       },
   },
};

Implement an ERC-20 token by creating a new Solidity file, mytoken.sol, and pasting the following code into your contracts directory :
 

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract OPToken {
   string public name;            
   string public symbol;          
   uint8 public decimals;         
   uint256 public totalSupply;  
   mapping(address => uint256) public balanceOf;            
   mapping(address => mapping(address => uint256)) public allowance;
   
   event Transfer(address indexed from, address indexed to, uint256 value);
   event Approval(address indexed owner, address indexed spender, uint256 value);
   
   constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) {
       name = _name;
       symbol = _symbol;
       decimals = _decimals;
       totalSupply = _initialSupply * (10 ** uint256(decimals));
       balanceOf[msg.sender] = totalSupply; // Assign all tokens to the deployer
   }
   
   function transfer(address _to, uint256 _value) public returns (bool success) {
       require(balanceOf[msg.sender] >= _value, 'Insufficient balance');
       _transfer(msg.sender, _to, _value);
       return true;
   }
   
   function _transfer(address _from, address _to, uint256 _value) internal {
       require(_to != address(0), 'Cannot transfer to zero address');
       balanceOf[_from] -= _value;
       balanceOf[_to] += _value;
       emit Transfer(_from, _to, _value);
   }
   
   function approve(address _spender, uint256 _value) public returns (bool success) {
       allowance[msg.sender][_spender] = _value;
       emit Approval(msg.sender, _spender, _value);
       return true;
   }
   
   function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
       require(balanceOf[_from] >= _value, 'Insufficient balance');
       require(allowance[_from][msg.sender] >= _value, 'Allowance exceeded');
       _transfer(_from, _to, _value);
       allowance[_from][msg.sender] -= _value;
       return true;
   }
}

Also, Check | How to Write and Deploy Modular Smart Contracts

4. Compile the Contract.
 

Within your terminal, execute the following command:
Bash: Npx Hardhat Compile

5. Deploy the Contract:

Make a scripts/deploy.js file to automate the deployment procedure:
 

async function main() {
   const MyToken = await hre.ethers.getContractFactory('MyToken');
   const myToken = await MyToken.deploy('MyToken', 'MTK', 18, 1000000); 
   await myToken.deployed();
   console.log('MyToken deployed to:', myToken.address);
}
main().catch((error) => {
   console.error(error);
   process.exitCode = 1;
});

Deploy the contract via the Hardhat console:

Bash:Run scripts/deploy.js --network opSepolia using npx hardhat

Also, Explore | How to Deploy a Smart Contract to Polygon zkEVM Testnet

Conclusion:

Optimism aims to enhance the Ethereum ecosystem by offering scalable Layer 2 solutions. While its optimistic roll-up methodology shares similarities with others, its implementation and features set it apart. Currently a strong second-place contender, Optimism has the potential to challenge Arbitrum's dominance in the future. If you are looking to build your project leveraging Optimism blockchain, connect with our expert blockchain developers to get started.