Key Points 

References

Key Concepts

Ethereum Concepts

Ethereum Layer 2 roadmap

https://cointelegraph.com/news/vitalik-buterin-outlines-endgame-roadmap-for-eth-2-0

layer2-Vitalik Buterin outlines endgame roadmap for ETH 20.pdf

both optimistic and zero knowledge proof rollups

https://finance.yahoo.com/news/ethereum-no-longer-one-chain-123000149.html

Ethereum is no longer a one-chain ecosystem. In order to achieve scalability, the Ethereum community will need to offer layer 2 technologies capable of handling transactions from billions of users. 2021 proved to be the first step in experimentation with both optimistic and zero knowledge proof rollups, and the two finally began to take significant market share in daily transactions away from Ethereum L1.

Ethereum Smart Contract Development

https://medium.com/blockchain-stories/the-story-of-an-ethereum-smart-contract-e0df5c526724

ethereum-smart-contract-dev-p1-The Story Of An Ethereum Smart Contract _ by Kerala Blockchain Academy _ Blockchain Stories _ Jun, 2022 _ Medium.pdf file

ethereum-smart-contract-dev-medium.com-Interacting with an Ethereum Smart Contract.pdf file

Basic steps to run a smart contract on a blockchain

1. The distributed ledger should be equipped to record computer programs.
2. Whenever a user executes a DApp, the execution should happen at every peer/computer holding the ledger copy.
3. The nodes (network participants holding the blockchain copy) should have an execution environment to execute the DApp.
4. The system should have a mechanism to uniquely identify a program, its associated data and its executions.
5. Finally, these changes should be recorded as transactions on the chain.

Smart contract environment

• Smart contracts ( SC ) run on an emulated computer called the Ethereum Virtual Machine (EVM).
• Each node on the Ethereum network runs a local copy of the EVM to validate contract execution.
• At the same time, the Ethereum blockchain records the changing state of this world computer as it processes transactions and smart contracts. 
• The EVM operates like a global, single-instance computer, running everywhere.
• Each smart contract is uniquely identified by its 20-byte contract address and has a smart contract program code
• Each SC is owned and controlled by the logic of its smart contract program code that is recorded on the Ethereum blockchain at the contract account’s creation and executed by the EVM.
  • No one can steal the funds of a smart contract since it does not have a private key to be stolen.
• Contract funds are accessed only by programming the transfers in the smart contract code, which is publicly auditable.
• Externally Owned Accounts or EOAs are controlled by users using their private keys.
  • They are often managed by wallet applications external to the Ethereum platform.
• Smart contract deployment is also a blockchain transaction
• Smart contracts are written in high-level languages like Solidity

// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;

contract MyContract {
    string message = "Hello Ethereum";

    function setMessage(string memory _message) public {
        message = _message;
    }

    function getMessage() public view returns (string memory) {
        return message;
    }
}

Smart Contract Gas Fees on Ethereum

Ethereum introduces a metering mechanism called gas. As the EVM executes a smart contract, it carefully accounts for every instruction (computation, data access, etc.). Each instruction has a predetermined cost in units of gas. When a transaction triggers the execution of a smart contract, it must include an amount of gas that sets the upper limit of what can be consumed running the smart contract. The EVM will terminate execution if the amount of gas consumed by computation exceeds the gas available in the transaction.

 The Solidity compiler (solc) converts the smart contract to EVM bytecode

The compiler also generates an Application Binary Interface (ABI). ABI serves as an interface between two program modules. It defines how data structures and functions are accessed in machine code.

Deployment after compile

the contract can be deployed using a particular contract deployment transaction. Once the transaction is included in a block, the contract can be referred to by its address. The address of a smart contract is calculated as a hash function of the originating account and account nonce (number of transactions originated from an account).

An Ethereum user who wants to interact with a smart contract can use the contract address and ABI to interact with it anytime.

MyContract is deployed in Ropsten testnet at contract address 0x0dFA0638dd508bFb4E13A06359FAF666677D7F4d. You can check the contract status at the block explorer.

Interact with Ethereum Smart Contracts

https://medium.com/blockchain-stories/interacting-with-an-ethereum-smart-contract-aa14401c30a0

ethereum-smart-contract-dev-medium.com-Interacting with an Ethereum Smart Contract.pdf

Please note that in the previous article we deployed the smart contract in Ropsten test network. Since Ropsten test network is expected to be shut down later this year, we have used a similar smart contract deployed in Goerli testnet here.

Contract Address (Goerli): 0x44E84A10341BF772906c37fFc30CDbb132eA35f2

https://goerli.etherscan.io/address/0x44e84a10341bf772906c37ffc30cdbb132ea35f2

Connect your test wallet to the testnet

We can interact with an already deployed smart contract by using its contract address and the ABI. For that, we first need to connect to the blockchain network. Wallets are simple applications allowing users to connect with a blockchain network. They act as account managers who manage the user’s keys and transactions. We will be using a MetaMask wallet to connect with the Goerli test network, which got our smart contract. MetaMask installation is already described in our previous blog on HD Wallets. Kindly follow those instructions to install MetaMask.

Connection goes to mainnet so switch to the testnet

Get test ether from a faucet to fund your wallet

Click on the network name, and enable visibility of test networks. Now switch to Goerli test network.

To interact with the contract using the wallet, it should have some ether balance. Goerli is a test network, and its cryptocurrency (Goerli ETH) is available for free from certain sources called faucets. You can go to any of the below links and request Goerli ETH by sharing your account address.

Faucets: https://goerli-faucet.slock.it/, https://faucet.goerli.mudit.blog/. Remember, these are test ethers which do not have any monetary value.

Interact with the Contract thru an IDE

Remix IDE is an open-source web and desktop application. You can directly access it from your web browser; just go to https://remix.ethereum.org.

Open a new file and copy the ABI from https://goerli.etherscan.io/address/0x44E84A10341BF772906c37fFc30CDbb132eA35f2#code. Save it as filename.abi

Ethereum Optimizations

Optimistic Roll up strategies to combine offline transactions online

https://www.coindesk.com/layer2/2022/02/16/ethereums-rollups-arent-all-built-the-same/

Optimistic rollups do not largely change the trust assumptions of Ethereum, as any user is capable of running a sequencer (Arbitrum full node) that processes transactions and allows users to withdraw funds to mainnet. Sequencers are required to put up a “fidelity bond” on mainnet, thereby creating a financial incentive to be truthful. If another user disputes the sequencer’s transactions, and they are found to be dishonest, the fidelity bond is paid out to the disputer. Financial incentives and multiple sequencers will allow the layer 2s to have strong uptime performance and lean on Ethereum’s security without the concern of interference.

By socializing gas cost across bundled users and only posting calldata to mainnet, Optimistic rollups are able to achieve transaction fees 10-100x cheaper than the corresponding transaction on Ethereum layer 1. These fees will continue to get cheaper as data storage is optimized on mainnet for rollups and sharding, splitting the network in multiple chains to relieve congestion, is eventually implemented.

ZK Rollups

Zero knowledge (zk) rollups bunch together hundreds of off-chain transactions using extensive computation and post them bundled to mainnet in what is known as a “validity proof.” The validity proof is the already computed state of the layer 2 that is sent to mainnet for storage, which contains much less data than the calldata used in Optimistic rollups. Starkware, Polygon Hermez and zkSync are a few of the first implementations of Ethereum based zk rollups creating low cost, application specific layer 2s

Since zk rollups are so computationally intensive and is of limited to a few use cases.

EIP for Stake withdrawals

A new Ethereum Improvement Proposal (EIP) would set the foundation for staked ether withdrawals after the transition to proof-of-stake. BACKGROUND: While the EIP won’t immediately allow validator withdrawals, it sets the stage for the simple upgrade that makes the process possible.

POS consensus

Web3 frameworks for Ethereum

https://web3js.readthedocs.io/en/v1.2.0/getting-started.html

The web3.js library is a collection of modules which contain specific functionality for the ethereum ecosystem.

• The web3-eth is for the ethereum blockchain and smart contracts
• The web3-shh is for the whisper protocol to communicate p2p and broadcast
• The web3-bzz is for the swarm protocol, the decentralized file storage
• The web3-utils contains useful helper functions for Dapp developers.

// in node.js use: var Web3 = require('web3');

var web3 = new Web3(Web3.givenProvider || "ws://localhost:8546");

EEA Off-Chain Trusted Computing Spec

https://entethalliance.github.io/trusted-computing/spec.html

This document specifies APIs that enable off-chain Trusted Computing for Enterprise Ethereum. In this release, The Trusted Computing specification enables privacy in blockchain translations, moving intensive processing from a main blockchain to improve scalability and latency, and support of attested Oracles

This specification has four objectives:

• Support private transactions on a blockchain between mutually-untrusting parties without disclosing transaction details to other parties who also have access to the blockchain.
• Support disclosure of selected information to chosen parties on a blockchain, while maintaining the secrecy of other information from those same chosen parties ("selective Privacy").
• Move intensive processing from a main blockchain to an off-chain Trusted Compute capability thereby improving throughput and scalability.
• Support Attested Oracles.

These objectives are achieved by executing some parts of a blockchain transaction off the main chain in off-chain trusted computing. There are currently three types of Trusted Compute that are supported by this specification:

• Trusted Execution Environments (Hardware based)
• Zero-Knowledge Proofs (Software based)
• Trusted Multi-Party-Compute (MPC) (Software/Hardware based)

The APIs are grouped in registration, invocation and receipt handing sections. Attested Oracles are considered a special application of Trusted Compute used to create increased trust in an Oracle, and can be implemented using the defined APIs.

Article on EEA TCE

https://blog.chain.link/driving-demand-for-enterprise-smart-contracts-using-the-trusted-computation-framework-and-attested-oracles-via-chainlink/

Blockchains can greatly enhance their capacity to meet enterprise requirements around privacy and scalability by using Chainlink oracles to route transactional computation off-chain to the Trusted Computation Framework (TCF).

advantages and limitations of public blockchains, as well as outline the TCF architecture and how attested oracles via Chainlink can enable bi-directional connectivity between on-chain and off-chain environments. To demonstrate how this system works, we detail three industry uses cases in finance, insurance, and global trade in which TCF, Chainlink, and underlying blockchains can work in unison to improve backend business processes and reduce costs for both enterprises and consumers.

Key Points on Ethereum Public Blockchains

1. the infrastructure that powers multi-party transactional contracts. They offer a shared computational platform that stores, maintains, executes, and settles the contract for all parties involved. Participating parties can neither decommit from their obligations nor tamper with the process once the contract is set in motion on the blockchain
2. No need to trust counterparty or trusted 3rd party
3. Data-driven Contract deliverables can automatically be confirmed in many cases ( eg payment, shipments, receipts etc )
4. Lower cost, friction, time to settle with smart contracts
5. Better transparency and traceability ( provenance ) on origins ( eg Food Trust network tracks lots )
6. KYC compliance possible with Self-Sovreign Identities and Zero-Trust Knowledge proofs on public chains where supported

Challenges to overcome on public blockchains

1. Scalability ( to fit specific use cases )
2. Privacy
3. On-chain data scope

Off-chain data, privacy and execution needed to meet these challenges.

Integration with smart contracts needed via trusted agents or oracles.

Trusted agents option

1. Trusted agent is invoked by client apps or services
2. Agent executes in trusted environment and can access both off-chain data and services as well as on-chain contracts and data
3. Agent executes at top level, invokes contract as a service passing required data to the contract including

Oracles option

Blockchain App Development Concepts 101 - slideshare - sweetbridge

https://www.slideshare.net/Synerzip/blockchain-application-development-101

blockchain-application-development-webinar-sweetbridge-190905082233.pdf

Potential Value Opportunities

Learning basic Ethereum Blockchain

Joshua Ellul 09:44 AM
It depends. If you have programming experience, then I would say find tutorials online and just get your hands dirty. You can use remix.ethereum.org which is an easy to use IDE to start trying out some smart contracts. There are also other languages supported by different platforms, e.g. cosmos: golang; substrate/polkadot: Rust; Neo/stratis: .NET; Algorand: Python and many more

If you do not have programming experience, I would recommend starting a programming course in a language like Python.

Joshua Ellul 09:46 AM
I had also written aa tutorial, that I tried to make as easy as possible to follow:
http://blockchainthings.io/article.aspx?i=2&t=1
http://blockchainthings.io/article.aspx?i=3&t=1
http://blockchainthings.io/article.aspx?i=7&t=1
http://blockchainthings.io/article.aspx?i=9&t=1
http://blockchainthings.io/article.aspx?i=10&t=1
http://blockchainthings.io/article.aspx?i=12&t=1
http://blockchainthings.io/article.aspx?i=13&t=1

Joshua Ellul 09:49 AM
There are also some smart contract platforms that allow for them to be created using templates (e.g. a web based interface), and no-code platforms. As well as some that allow for natural language (English etc) definition of smart contracts

Joshua Ellul 09:53 AM
I haven’t tried this, but it may be something to look into: https://transientnetwork.io/

Potential Challenges

Candidate Solutions

Step-by-step guide for Example

sample code block

Recommended Next Steps

Related articles