Blockchain is a sequential list of records called blocks that store data publicly and in chronological order.

The participants of the Network have access to the Blockchain data, maintain the data, and hold the democratic right to approve transactions within the Blockchain network.

Every transaction on the ledger is authorized by the digital signature of the owner, authenticating and safeguarding it from tampering.

What is a Cryptographic Hash Function?

A cryptographic hash is a mathematical one-way function that converts a numerical input value of arbitrary length to a compressed numerical output value of fixed length.

Properties of a cryptographic hash include the following:

• Non-reversibility: A good cryptographic hash makes it hard to reconstruct the original value from the output.

• Avanlanche effect: A small change in the original value causes a significant change in half the bits of its hash.

• Determinism: A given value must always generate the same hash value.

• Collision resistance: A good cryptographic hash function should make it hard to generate the same encoded text from two input values.

• Predictable: The hash value should not be predictable from the original value.

What is Public Key Cryptography?

Public key cryptography is an encryption scheme that uses two mathematically similar but non-identical keys, a private and a public key.

The public key is used to encrypt, while the private key is used to decrypt.

Because it is computationally infeasible to generate the private key from the public key, public keys are freely shared, allowing users an easy and convenient method for encrypting content and verifying digital signatures.

Merkle Trees

A Merkle tree is a way of hashing a large amount of data, which relies on splitting the data chunks into buckets, where each bucket contains only a few chunks, then taking the hash of each bucket, and repeating the process until the total number of chunks remaining is one.

However, Ethereum uses the Patricia Merkle tree, a combination of the Patricia tree and the Merkle tree.

What is Ethereum?

Ethereum is a deterministic and practically unbound state machine.

Ethereum is made up of a globally accessible singleton state and an EVM that applies changes to that state.

Ether (ETH) is Ethereum’s native currency

It provides a mechanism to fuel the computational resources required to execute transactions and run applications on the Ethereum network.

Ethereum developers and community metaphorically refer to ETH as the fuel that powers the network.

The Merkle tree starts from the chunks of hash to determine the root, meaning the root is unknown until the stored chunks are combined to get the root. The root is stored in a block head.

Blockchain Components

P2P Network

Consensus rules: These are rules that determine how the network agrees on a single, consistent version of the Blockchain.

Transactions: These are cryptographically signed instructions that determine updates in the state of the Ethereum network.

State machines: These are behavioral models that describe how something behaves based on its current state and what happens next

Data Structures: This includes transactions and system state in a serialized hash data structure called the Merkle Patricia tree.

Nodes and Clients: Nodes are devices that run the Ethereum client and maintain a partial or full copy of the blockchain.

Ether (ETH)

Ether is the currency unit of Ethereum.

[if !supportLists]· [endif]The smallest possible unit of Ether is wei.

Externally Owned Accounts and Contracts

Externally Owned Accounts (EOAs) are accounts created with a wallet.

EOAs have private keys that provide control over access to funds and contracts.

Contract accounts, on the other hand, have smart contracts and are controlled by the logic of the smart contract code.

However, contract accounts do not have private keys and, as such, can’t initiate transactions.

Contracts can react to transactions by calling other Contracts.

Smart Contracts

These are self-executing programs that are uploaded to the EVM state and executed by the network. They perform some actions once certain conditions are satisfied.

Ethereum Virtual Machine (EVM)

The EVM is the global virtual computer whose state every participant in the network stores and agrees on.

Transactions

Transactions are cryptographically signed instructions from accounts that initiate a transfer to update the EVM state.

Ethereum transactions refer to actions initiated from an EOA.

Because a transaction changes the EVM state, it needs to be broadcast to the network.

Any node can broadcast a request for a transaction to be executed on the EVM.

Once achieved, a validator executes the transaction and propagates the resulting state change to the rest of the network.

Node and Clients

A node is any instance of Ethereum client software that is connected to other devices also running Ethereum software, forming a network.

An Ethereum client is a software that follows the Ethereum rules.

It contains information on how Ethereum works.

It checks everything from transactions to blocks against the Ethereum rules, ensuring the security of the network.

A node runs two clients: A consensus client and an execution client.

The execution client listens for new transactions broadcast on the network and executes them in the EVM.

The consensus client (Beacon Node) implements the PoS consensus algorithm, enabling the network to reach an agreement based on validated data from the execution client.

Node Types

The different types of Nodes include:

Full Nodes: These do a block-to-block validation of the blockchain, including downloading and verifying the block body and state data of each block. Full nodes can verify every single block by storing the entire history of the blockchain.

Archive nodes: These are full nodes that verify every single block from genesis and never delete any downloaded data.

Light nodes: These nodes only download block headers.

In PoS, validators are required to stake ETH for the privilege to propose new blocks and collect rewards. But what happens if a validator behaves dishonestly or fails to follow the rules? And how does Ethereum defend itself against potential attacks under this new system?

This article discusses the rewards and penalties for validators and the security measures that keep the network safe. Let’s dive right in.

PoS Rewards

Central to PoS are validators, the main actors responsible for attesting to blocks and proposing new ones. The attestation process requires at least 128 validators to be assigned to attest in each 12-second slot. Additionally, the network assigns the role of block proposer to one validator to propose one block per slot. Validators receive rewards when they make consistent votes with the majority of other validators, when they propose blocks, and when they participate in sync committees. The value of each epoch’s rewards is calculated from a base_reward. The base_reward equals the average reward received by a validator under optimal conditions per epoch. Where one epoch represents 32 slots and one slot represents 12 seconds in Ethereum’s PoS system. Therefore, the base_reward is calculated as follows:

base_reward = effective_balance * (base_reward_factor / (base_rewards_per_epoch * sqrt(sum(active_balance))))

This means the base reward is directly proportional to the validator's effective balance and inversely proportional to the number of validators on the network. The more validators, the greater the overall issuance (as sqrt(N) but the smaller the base_reward per validator (as 1/sqrt(N)).

Pos Penalty

So far we have considered the reward for perfectly well-behaved validators, but what happens when validators that do not make timely head, source and target votes or do so slowly?

The penalties for missing the target and source votes equals the rewards the attestor would have received had they submitted them. This means that the system removes an equal value of the reward from their balance. There is no penalty for missing the head vote. There is no penalty associated with the inclusion_delay , meaning the reward will simply not be added to the validator's balance. There is also no penalty for failing to propose a block.

However, there is a more severe penalty called Slashing. This action results in the forceful removal of a validator from the network and an associated loss of their staked ether. It results from dishonest proposal or attestation of blocks in the following ways

• By proposing and signing two different blocks for the same slot

• By attesting to a block that "surrounds" another one (effectively changing history)

• By "double voting" by attesting to two candidates for the same block.

PoS Security

Thieves and saboteurs are constantly seeking opportunities to attack Ethereum’s client software. This section discusses the PoS security measures in place to avert such successful attacks.

The PoS security measures in place against attacks include the following:

• Re-org

• Double finality

• Finality delay

Re-org

This is a reshuffling of blocks into a new order, with some addition or subtraction of blocks in the canonical chain. A malicious reorg might ensure specific blocks are included or excluded, allowing double-spending or value extraction by front-running and back-running transactions (MEV). Re-orgs could also prevent certain transactions from being included in the canonical chain. The “finality reversion” represents the most extreme form of reorg, which removes or replaces blocks that have previously been finalized. This is only possible if more than ⅓ of the total staked ether is destroyed by the attacker in a form known as the “economic finality.”

Double Finality

This is an unlikely but severe condition. It’s a situation where two forks finalize simultaneously, creating a permanent schism in the chain. This is theoretically possible if an attacker is willing to sacrifice 34% of the total staked ether. The community would be forced to coordinate offchain and come to an agreement about which chain to follow, which would require strength in the social layer.

Finality Delay

This attack prevents the network from reaching the conditions necessary for finalizing sections of the chain. Without finality, financial applications built on top of Ethereum lose credibility. The aim of a finality delay attack is simply to disrupt Ethereum rather than to directly profit, unless the attacker has some strategic short position(s).

Conclusion

The Ethereum’s PoS not only provides an understanding of the behavioural tendencies of validators or stakers, but also highlights the robust mechanism designed to ensure fairness, reliablity and security across the network.

Finally, the PoS lays the groundwork for greater scalability and long-term growth and investment, enabling Ethereum to evolve into a more sustainable, secure, and decentralized platform for the future.

In this article, we’ll provide a brief overview of Ether, Ethereum’s native cryptocurrency. You’ll learn how to:

• Securely store your Ether with the right wallet

• Obtain and transfer the test Ether for development or experimentation

• Switch between networks (e.g., mainnet and testnets)

We'll also introduce smart contracts, explaining how to create one on the blockchain and interact with it effectively.

Understanding Ether: A Brief Overview

Ether (ETH) is Ethereum’s native cryptocurrency. It was created to provide a mechanism for users to fuel the computational resources required to execute smart contracts and run applications on the Ethereum network. This provided an incentive for participants to verify and execute transaction requests and provide computational resources to the network. Ethereum developers and community metaphorically refer to ETH as the gas that powers the network. This is because ETH is exchanged for the work done to verify transactions and secure the blockchain, similar to money spent to buy the gas that powers a car. ETH has also evolved into a cryptocurrency of market value that is exchangeable for fiat currency on cryptocurrency exchanges.

Ether is subdivided into smaller units, down to the smallest unit possible, named wei. Where one ETH equals 1 quintillion wei (1 * 10¹⁸ or 1,000,000,000,000,000,000). Internally, the ETH’s value is represented in Ethereum as an unsigned integer denominated in wei. Therefore, one ETH transaction encodes 1 × 10¹⁸ as the value.

Securely Storing Your ETH with the Right Wallet

The term wallet refers to a software application that helps you manage your crypto assets, and in this case, the assets in your Ethereum account. There are many different wallet options with different features and designs that make choosing the right wallet tedious. While some are suited for different levels of expertise, the best wallets are often the ones that adapt to the changes that come with the platform upgrades.

One important thing to remember is that for a wallet application to work, it must have access to your private keys, so ensure that you only download and use wallet applications from trusted sources. Below are a few selected options based on a broad range of complexity and features. However, these selections are not an endorsement of their quality or security. They are simply a good starting place:

• Metamask

• Jaxx

• MyEtherWallet (MEW)

• Emerald Wallet

Obtaining and Transferring Test ETH

Funding your wallet for testing and development involves utilizing the Test Network because real ether costs money, and handling it requires a bit more experience. Interacting with the Test Networks requires test ETH, which has no real-world value but behaves like real ETH.

You can get test ETH through a faucet, a free service that sends small amounts of test ETH to your wallet. Below are the steps to achieve this:

1. Set up a wallet (e.g., MetaMask) and connect it to a test network like Sepolia.

2. Copy your wallet address.

3. Visit a faucet website (e.g., Sepolia Faucet).

4. Paste your wallet address and request some test ETH.

5. After a few moments, the test ETH will appear in your wallet.

Once you have your test ETH, you can send it like regular ETH in the following steps:

1. Open your wallet and select the Send option.

2. Enter the recipient's address.

3. Specify the amount of test ETH you want to send.

4. Confirm and complete the transaction.

5. View the transaction status on a block explorer (like Goerli Etherscan).

Understanding Smart Contract

A smart contract is a self-executing script/program that depicts and enforces the terms of an agreement directly in lines of code. Once deployed on the blockchain, it runs automatically, triggering outcomes when predefined conditions are met, without the need for intermediaries.

You can think of a smart contract like a washing machine where you input settings like wash time, temperature, etc., and once started, it runs autonomously through each step of the cycle. When the timer reaches zero, the machine stops, and your clothes are ready. Similarly, a smart contract carries out instructions, which, once triggered, its outcomes are guaranteed by the blockchain. Now, let’s see how to create a simple smart contract.

Creating a Smart Contract

Ethereum provides many tools to write a contract and produce EVM bytecode. One of these tools is by far the dominant choice for smart contract programming, called Solidity. Solidity is a high-level language created by Dr. Gavin Wood. It is what we’ll use to create our first contract.

Our first example involves creating a contract that controls a faucet. Below are the steps to achieve this:

• The first line is a comment:

    // SPDX-License-Identifier: CC-BY-SA-4.0
  

• The next thing is to write the starter for our actual contract:

    contract Faucet {}
  

• Next, we ensure the contract can accept any incoming amount:

    function withdraw(uint withdraw_amount) public {
  

  The function withdraw takes one unsigned integer (uint) argument named withdraw_amount. It is declared as a public function, meaning it can be called by other contracts.

• Next, we limit the withdrawals:

require(withdraw_amount <= 100000000000000000);

• Finally, we send the actual amount

    msg.sender.transfer(withdraw_amount);