<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dolapo Ajala on Medium]]></title>
        <description><![CDATA[Stories by Dolapo Ajala on Medium]]></description>
        <link>https://medium.com/@DolapoAjala?source=rss-5029937e6057------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*gax2A834JFGMbf0U4sUdhg.webp</url>
            <title>Stories by Dolapo Ajala on Medium</title>
            <link>https://medium.com/@DolapoAjala?source=rss-5029937e6057------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:01:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@DolapoAjala/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Your Wallet Shows a Name Instead of an Address]]></title>
            <link>https://medium.com/@DolapoAjala/crypto-ux-has-been-a-great-let-down-in-the-adoption-of-web3-12911af5818b?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/12911af5818b</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[defi]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 14:19:11 GMT</pubDate>
            <atom:updated>2026-04-16T16:28:10.331Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jhctcWLD3y9OzPx8hfwaVw.jpeg" /></figure><p>Crypto UX has been a great let down in the adoption of web3. One of the hardest stuff to remember are wallet addresses (0x742d35Cc6634C0532925a3b844Bc454e4438f44e). It is hard to remember, easy to mistype and dangerous because one wrong character results in lost funds. This is where the Ethereum Name Service comes in.<br>The <strong>Ethereum Name Service(ENS) </strong>is an Ethereum-based decentralized naming system. The ENS is a suite of smart contracts implementing a secure and decentralized domain name system, built upon the Public Suffix List. The smart contract automates the process of claiming and assigning human-readable names in a way that can be integrated into virtually any decentralized application.</p><p>Most people understand ENS as: <strong>dolapo.eth -&gt; 0x123…</strong> but there’s a less talked about layer that powers everyday UX. <strong>Reverse resolution,</strong> 0x123… -&gt; dolapo.eth and behind that is one contract R<a href="https://github.com/ensdomains/ens-contracts/blob/staging/contracts/reverseRegistrar/ReverseRegistrar.sol"><strong>everseRegistrar</strong></a><strong>.sol</strong></p><h3>ReverseRegistrar Contract</h3><p>The ReverseRegistrar contract from the Ethereum Name Service implements reverse resolution. It maps an Ethereum address to ENS name. This contract is responsible for:</p><ul><li>Creating reverse records under<em> </em><strong><em>addr.reverse</em></strong></li><li>Assigning ownership of those records</li><li>Setting the <strong><em>name()</em></strong> field via a resolver</li></ul><h4><strong>File-Level Variables</strong></h4><ol><li><strong>lookup — Hex digit mapping for address hashing</strong></li></ol><pre>bytes32 constant lookup = 0x3031323334353637383961626364656600000000000000000000000000000000;</pre><p>This is a lookup table used in the sha3HexAddress function to convert an Ethereum address into its lowercase hex string representation — which is then hashed to create the ENS reverse node.</p><ul><li>The first 16 bytes (30 to 66) are the ASCII codes for &#39;0&#39; to &#39;f&#39; — the hex digits.</li><li>The rest are zeros (padding to 32 bytes).</li><li>The assembly code in sha3HexAddress uses this to efficiently build the hex string of an address without string operations.</li></ul><blockquote><strong><em>Purpose</em></strong><em>: Speed up converting an address like </em><em>0x123...abc into </em><em>&quot;123...abc&quot; for hashing.</em></blockquote><p>2. <strong>ADDR_REVERSE_NODE — The root node for reverse records</strong></p><pre>bytes32 constant ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;</pre><p>This is the ENS node hash for the special domain addr.reverse.</p><ul><li>In ENS, reverse records map addresses → names (e.g., 0x123...abc.addr.reverse → myname.eth).</li><li>This constant is the parent node under which all reverse records are created.</li><li>When you call claimForAddr, it computes a subnode like: keccak256(ADDR_REVERSE_NODE, sha3HexAddress(addr))<br>which gives you the unique ENS node for that address’s reverse record.</li></ul><blockquote><em>Example: If your address is </em><em>0x123...abc, its reverse node is: </em><em>keccak256(0x91d1...a9e2, keccak256(&quot;123...abc&quot;))</em></blockquote><h4><strong>Inheritance</strong></h4><pre>contract ReverseRegistrar is Ownable, Controllable, IReverseRegistrar</pre><p>The contract inherits the following modules:<br>- <strong>OpenZeppelin Ownable: </strong>Provides <strong><em>onlyOwner, </em></strong>used for admin operations.<br>- <strong>Controllable</strong>: Maintains a <strong><em>controllers</em></strong> mapping and allows delegated actors (like dApps) to manage records.<br>- <strong>IReverseRegistrar</strong>: Interface defining expected external behavior.</p><h4><strong>State Variables</strong></h4><ol><li><strong>ENS Registry Reference</strong></li></ol><pre>ENS public immutable ens;</pre><p>This points to the ENS registry contract. It is used for <strong><em>setSubnodeRecord</em></strong>, <strong><em>owner</em></strong> and <strong><em>isApprovedForAll.</em></strong></p><p><strong>2. Default Resolver</strong></p><pre>NameResolver public defaultResolver;</pre><p>Resolver used when none is explicitly provided.</p><p><strong>CORE FUNCTIONS<br>1. setDefaultResolver</strong></p><pre>function setDefaultResolver(address resolver) public onlyOwner</pre><p>It sets global resolver used in claim() and setName(). It centralized control (owner) ensures resolver consistency across users.</p><p>2. <strong>claim</strong></p><pre>function claim(address owner) public returns (bytes32)</pre><p>It claims the reverse record for msg.sender and assigns ownership to the address passed in the parameter. Returns the ENS node as bytes32. Internally, it delegates to claimForAddr(msg.sender, owner, address(defaultResolver)).</p><p>3. <strong>claimForAddr</strong></p><pre>function claimForAddr(<br>    address addr,<br>    address owner,<br>    address resolver<br>) public override authorised(addr) returns (bytes32)</pre><p>This is the core function of the contract. It creates or updates the reverse ENS record for a given address, assigning both an owner and a resolver. Every other claim-related function (claim, claimWithResolver) ultimately delegates to this one.<br>Here’s what happens step by step:</p><ol><li>It computes the label hash of the address using sha3HexAddress(addr)the keccak256 of its lowercase hex representation.</li><li>It derives the full reverse node: keccak256(ADDR_REVERSE_NODE, labelHash).</li><li>It calls ens.setSubnodeRecord(...) to register the subnode under addr.reverse with the specified owner and resolver.</li><li>It emits a ReverseClaimed event.</li></ol><p>The authorised modifier gates this function, allowing only the address itself, a controller, an ENS-approved operator, or the owner of the contract at that address to call it.</p><p>4. <strong>claimWithResolver</strong></p><pre>function claimWithResolver(address owner, address resolver) public returns (bytes32)</pre><p>A convenience wrapper around claimForAddr that lets msg.sender claim their reverse record while specifying a custom resolver. Useful when you want a resolver other than the default. For example, a custom resolver that supports additional record types.</p><p><strong>5. setName</strong></p><pre>function setName(string memory name) public returns (bytes32)</pre><p>The most user-facing function in the contract. It does two things in one call:</p><ol><li>Claims the reverse record for msg.sender (via claimForAddr), using the defaultResolver.</li><li>Calls setName(node, name) on that resolver to store the human-readable name.</li></ol><p>This is the function a wallet or dApp calls when a user sets their primary ENS name. Under the hood, it delegates to setNameForAddr.</p><p>6. <strong>setNameForAddr</strong></p><pre>function setNameForAddr(<br>    address addr,<br>    address owner,<br>    address resolver,<br>    string memory name<br>) public returns (bytes32)</pre><p>The generalized version of setName. It allows a controller or authorized party to set the reverse name for <em>any</em> address — not just msg.sender. This is critical for smart contract wallets, multisigs, and protocols that want to set a reverse record on behalf of a contract they own.</p><p>It calls claimForAddr first to establish ownership and resolver, then calls resolver.setName(node, name) to write the name.</p><p><strong>7. node</strong></p><pre>function node(address addr) public pure returns (bytes32)</pre><p>A read-only utility. Returns the ENS node hash for an address’s reverse record without writing anything on-chain. Useful for off-chain lookups or pre-computing a node before interacting with the registry.</p><p><strong>8. sha3HexAddress</strong></p><pre>function sha3HexAddress(address addr) private pure returns (bytes32 ret)</pre><p>This is the most technically interesting function in the contract. It uses inline assembly to compute the keccak256 hash of the lowercase hex string of an Ethereum address without allocating a dynamic string in Solidity.</p><p>Here’s what it does:</p><ul><li>It iterates over 40 hex characters (20 bytes × 2 nibbles each), working backwards.</li><li>For each nibble, it uses the lookup constant to map the nibble value (0–15) to its ASCII hex character (&#39;0&#39;–&#39;f&#39;).</li><li>It writes each character into memory at position 0–39.</li><li>Finally, it hashes the 40-byte memory region with keccak256(0, 40).</li></ul><p>The result is the same as keccak256(abi.encodePacked(toHexString(addr))) but far more gas-efficient. ENS uses this to derive the label under addr.reverse — so 0x742d...f44e becomes the node keccak256(&quot;742d...f44e&quot;).</p><p><strong>9. ownsContract</strong></p><pre>function ownsContract(address addr) internal view returns (bool) {<br>    try Ownable(addr).owner() returns (address owner) {<br>        return owner == msg.sender;<br>    } catch {<br>        return false;<br>    }<br>}</pre><p>Checks whether msg.sender is the Ownable owner of the contract at addr. Used inside the authorised modifier. If the call reverts (e.g. the address isn&#39;t a contract, or doesn&#39;t implement owner()), it safely returns false.</p><h4><strong>Some Pitfalls and Limitations</strong></h4><p>The ReverseRegistrar is well-designed for its scope, but there are real edge cases and risks worth understanding.</p><p><strong>1. Reverse records are not automatically verified</strong></p><p>Setting a reverse record does not prove you own the forward record. Anyone can set 0x123...abc → alice.eth even if alice.eth doesn&#39;t point back to 0x123...abc. Applications doing reverse resolution should always validate that the forward record matches — i.e., resolve alice.eth and check it equals the original address. ENS itself doesn&#39;t enforce this at the contract level.</p><p>2. <strong>No way to delete a reverse record</strong></p><p>Once a reverse record is set, there is no delete or clear function in this contract. To remove a reverse record, a user would need to call claimForAddr with a zero-address resolver and an empty name — but even that doesn&#39;t truly delete the subnode from the registry, it just orphans it. This is a usability gap for users who want to cleanly disassociate their address from a name.</p><p><strong>3. setNameForAddr does not validate the resolver</strong></p><pre>NameResolver(resolver).setName(node, name);</pre><p>The resolver address passed into setNameForAddr is never checked to be a valid ENS resolver. If a caller passes a malicious or incorrectly implemented contract address, the call will either revert (failing silently from the user&#39;s perspective) or execute unexpected code. There is no interface check or whitelist on resolver addresses.</p><p><strong>CONCLUSION</strong></p><p>ReverseRegistrar.sol is a compact but surprisingly nuanced contract. What looks like a simple name-mapping system actually touches ENS registry internals, custom assembly for gas efficiency, a layered authorization model, and an upgrade migration pattern in its constructor.</p><p>Understanding it fully means understanding how ENS nodes are derived, how reverse records differ from forward records, and why validating both directions matters for any dApp doing identity resolution. The pitfalls above aren’t bugs they’re mostly intentional trade-offs made for flexibility and gas efficiency but they’re critical knowledge if you’re building on top of this contract or auditing anything that integrates with ENS reverse resolution.</p><p>The next time your wallet shows dolapo.eth instead of 0x742d...f44e, you now know exactly which contract made that possible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12911af5818b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Hooks: A Simple Guide to State and Lifecycle Management in Functional Components]]></title>
            <link>https://medium.com/@DolapoAjala/react-hooks-a-simple-guide-to-state-and-lifecycle-management-in-functional-components-05fff6b6b9ae?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/05fff6b6b9ae</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-hook]]></category>
            <category><![CDATA[frontend-development]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 07:57:23 GMT</pubDate>
            <atom:updated>2026-03-18T07:57:23.117Z</atom:updated>
            <content:encoded><![CDATA[<p>React Hooks are built-in functions that enable you to manage data (state) and respond to component lifecycle events like loading or updating directly inside function components. They are functions with specific requirements that make them powerful tools for modern React development.</p><p>First, they must be used exclusively within function components and always called at the top level of your component, never nested inside loops or conditional statements. One of their key advantages is that they enable function components to maintain their own internal state through hooks like `useState`, allowing components to retain information and dynamically update their display based on that stored data. Additionally, React Hooks facilitate code reusability across multiple components by allowing developers to extract stateful logic into custom hooks, which can then be shared and applied wherever needed making tasks like data fetching more efficient and maintainable. Below are some React Hooks</p><h3><strong>useState</strong></h3><p>This is the most basic and commonly used hook. It allows you to store and update state in a functional component.</p><pre>import { useState } from &#39;react&#39;;<br><br>function MyComponent() {<br>  const [count, setCount] = useState(0); <br>  <br>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;You clicked {count} times&lt;/p&gt;<br>      &lt;button onClick={() =&gt; setCount(count + 1)}&gt;Click me&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>}</pre><p>In this example, useState(0 starts the count at 0. The setCount function updates it. useState gives back an array with the current state and a function to change it, which is why we use array destructuring to get count and setCount.</p><h3>useEffect</h3><p>This hook lets you do things after your component renders. For example, you can fetch data, set up subscriptions, or manually change the DOM. Here’s how you might fetch data:</p><pre>import { useEffect, useState } from &quot;react&quot;;<br><br>function MyComponent() {<br>  const [users, setUsers] = useState([]);<br><br>  useEffect(() =&gt; {<br>    fetch(&quot;https://api.example.com/users&quot;)<br>      .then(res =&gt; res.json())<br>      .then(data =&gt; setUsers(data));<br>  }, []); // runs once on mount<br><br>  return (<br>    &lt;ul&gt;<br>      {users.map(user =&gt; (<br>        &lt;li key={user.id}&gt;{user.name}&lt;/li&gt;<br>      ))}<br>    &lt;/ul&gt;<br>  );<br>}</pre><p>useEffect needs two things: a function to run and an array of values it depends on. If the array is empty [], it means the effect runs only once when the component is first shown and when it goes away.</p><h3>useContext</h3><p>This hook lets you context in your components. It is a way to pass data through your component tree without having to pass props down manually at every level like a global state. It is useful for themes, auth, global settings.</p><pre>import { createContext, useContext } from &quot;react&quot;;<br><br>const ThemeContext = createContext();<br><br>function App() {<br>  return (<br>    &lt;ThemeContext.Provider value=&quot;dark&quot;&gt;<br>      &lt;Child /&gt;<br>    &lt;/ThemeContext.Provider&gt;<br>  );<br>}<br><br>function Child() {<br>  const theme = useContext(ThemeContext);<br><br>  return &lt;p&gt;Theme: {theme}&lt;/p&gt;;<br>}</pre><h3>useRef</h3><p>This hook lets you have a way to hang onto something (like a DOM element) that doesnt get wiped out when your component re-renders. It’s like keeping a sticky note on something you don’t want to lose.</p><pre>import { useRef } from &quot;react&quot;;<br><br>function InputFocus() {<br>  const inputRef = useRef(null);<br><br>  const focusInput = () =&gt; {<br>    inputRef.current.focus();<br>  };<br><br>  return (<br>    &lt;&gt;<br>      &lt;input ref={inputRef} /&gt;<br>      &lt;button onClick={focusInput}&gt;Focus Input&lt;/button&gt;<br>    &lt;/&gt;<br>  );<br>}</pre><h3>useCallback</h3><p>It keeps your functions remembered so they don’t get recreated every time your component re-renders. This is especially handy for functions that need to stick around, like event handlers.</p><pre>import { useCallback } from &quot;react&quot;;<br><br>function MyComponent() {<br>  const handleClick = useCallback(() =&gt; {<br>    console.log(&quot;clicked&quot;);<br>  }, []);<br>  <br>  return &lt;button onClick={handleClick}&gt;Click&lt;/button&gt;;<br>}</pre><h3>useMemo</h3><p>This caches a computed value to avoid unnecessary recalculation. It is like a brainy assistant that remembers the result of a heavy-duty function so you don’t have to run it again unless absolutely necessary. It helps keep things running smoothly and quickly.</p><pre>import { useMemo } from &quot;react&quot;;<br><br>function ExpensiveComponent({ num }) {<br>  const expensiveCalculation = (n) =&gt; {<br>    console.log(&quot;Calculating...&quot;);<br>    return n * 1000;<br>  };<br><br>  const result = useMemo(() =&gt; expensiveCalculation(num), [num]);<br><br>  return &lt;p&gt;Result: {result}&lt;/p&gt;;<br>}</pre><p>React Hooks offer a more straightforward way to work with React features like state and lifecycles in your function components. By choosing hooks over more complicated setups, your code becomes easier to handle, test, and share. The real skill lies not just in knowing these hooks, but in understanding when to use them<strong> </strong>and when not to<strong>.</strong> Overusing optimization hooks can make your code harder to read without real performance gains.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05fff6b6b9ae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing Smart Contracts with Inheritance: Patterns, Pitfalls, and Best Practices]]></title>
            <link>https://medium.com/@DolapoAjala/designing-smart-contracts-with-inheritance-patterns-pitfalls-and-best-practices-95ed7bdef0b8?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/95ed7bdef0b8</guid>
            <category><![CDATA[solidity]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[inheritance]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Sat, 14 Feb 2026 20:54:42 GMT</pubDate>
            <atom:updated>2026-02-14T20:54:42.391Z</atom:updated>
            <content:encoded><![CDATA[<h3>Inheritance in Solidity</h3><p>Inheritance stands as a crucial element in object-oriented programming. It enables developers to expand program capabilities, organize code more effectively, minimize dependencies, and maximize code reusability. Within Solidity, smart contracts can inherit properties from one another, allowing a single contract to derive features from multiple sources. The contract providing features is termed the <strong>base (or parent)</strong> <strong>contract,</strong> while the one receiving features is called the derived <strong>(or child) contract.</strong></p><p>Solidity provides different types of inheritance</p><ol><li><strong>Single Inheritance</strong></li></ol><p>One parent contract passes its features to exactly one child contract.</p><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>// Defining parent contract<br>contract parent {<br><br>    // Declaring internal state variable<br>    uint internal sum;<br><br>    // Defining external function to set value of <br>    // internal state variable sum<br>    function setValue() external {<br>        uint a = 5;<br>        uint b = 15;<br>        sum = a + b;<br>    }<br>}<br><br>// Defining child contract<br>contract child is parent {<br><br>    // Defining external function to return value of <br>    // internal state variable sum<br>    function getValue() external view returns(uint) {<br>        return sum;<br>    }<br>}<br><br>// Defining calling contract<br>contract caller {<br><br>    // Creating child contract object<br>    child cc = new child();<br><br>    // Defining function to call setValue and getValue functions<br>    function testInheritance() public returns (uint) {<br>        cc.setValue();<br>        return cc.getValue();<br>    }<br>}</pre><p><strong>2. Multi-level Inheritance</strong></p><p>Similar to single inheritance but with multiple generational layers. A child contract that inherits from a parent can itself become a parent to another contract. Example: <strong>contracts A, B, and C</strong> forming a three-level hierarchy</p><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>// Defining parent contract A<br>contract A {<br>    uint internal sum;<br>    uint a = 10;<br>    uint b = 20;<br><br>    // Defining external function to calculate sum of a and b<br>    function getA() external {<br>        sum = a + b;<br>    }<br>}<br><br>// Defining child contract B inheriting parent contract A <br>contract B is A {<br>    uint public result;<br>    uint c = 30;<br><br>    // Defining external function to return sum of sum from A and c<br>    function getB() external payable returns(uint) {<br>        result = sum + c;<br>    }<br>}<br><br>// Defining child contract C inheriting parent contract A<br>contract C is B {<br>    // Defining external function returning final sum<br>    function getC() external view returns(uint) {<br>        return result;<br>    }<br>}<br><br>// Defining calling contract  <br>contract caller {<br>    // Creating object of child C <br>    C cc = new C();<br><br>    // Defining public function to return final calculated value  <br>    function testInheritance() public returns(uint) {<br>        cc.getA();<br>        cc.getB();<br>        return cc.getC();<br>    }<br>}</pre><p><strong>3. Hierarchical Inheritance</strong></p><p>One parent contract serves as the base for multiple child contracts. This pattern is useful when common functionality needs to be shared across different implementations. Example:<strong> contract A</strong> being inherited separately by both<strong> contracts B and C</strong>, each accessing different parent features.</p><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>// Defining parent contract A  <br>contract A {<br>    // Declaring internal <br>    // state variable<br>    string internal x;<br>   <br>    // Defining external function <br>    // to set value of <br>    // internal state variable x<br>    function getA() external {<br>        x = &quot;solidity&quot;;<br>    }<br>    <br>    // Declaring internal <br>    // state variable<br>    uint internal sum;  <br>    <br>    // Defining external function <br>    // to set the value of<br>    // internal state variable sum  <br>    function setA() external {<br>        uint a = 10;<br>        uint b = 20;<br>        sum = a + b;<br>    }<br>}<br><br>// Defining child contract B <br>// inheriting parent contract A<br>contract B is A {<br>    // Defining external function to <br>    // return state variable x<br>    function getAstr() external view returns(string memory) {<br>        return x;<br>    }<br>    <br>    // Defining external function to <br>    // return state variable sum<br>    function getAValue() external view returns(uint) {<br>        return sum;<br>    }<br>}<br><br>// Defining child contract C <br>// inheriting parent contract A<br>contract C is A {<br>    // Defining external function to <br>    // return state variable sum<br>    function getAValue() external view returns(uint) {<br>        return sum;<br>    }<br>}<br><br>// Defining calling contract    <br>contract caller {<br>    // Creating object of contract B       <br>    B contractB = new B();<br><br>    // Creating object of contract C<br>    C contractC = new C();   <br>    <br>    // Defining public function to <br>    // return values of state variables <br>    // x and sum<br>    function testInheritance() public returns(string memory, uint) {<br>        contractB.getA();<br>        contractC.setA();<br>        return (contractB.getAstr(), contractC.getAValue());<br>    }<br>}</pre><p><strong>4. Multiple Inheritance</strong></p><p>A single contract can inherit from several parent contracts simultaneously, and parent contracts can have multiple children. Example: <strong>contract C</strong> inheriting from both <strong>contracts A and B</strong></p><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>// Defining contract A  <br>contract A { <br>    // Declaring internal <br>    // state variable<br>    string internal x;<br><br>    // Defining external function <br>    // to set value of <br>    // internal state variable x<br>    function setA() external {<br>        x = &quot;solidity&quot;;<br>    }<br>}<br><br>// Defining contract B  <br>contract B {  <br>    // Declaring internal <br>    // state variable<br>    uint internal pow;  <br><br>    // Defining external function <br>    // to set value of internal<br>    // state variable pow<br>    function setB() external {  <br>        uint a = 2;<br>        uint b = 20;<br>        pow = a ** b;<br>    }<br>}  <br><br>// Defining child contract C <br>// inheriting parent contract <br>// A and B<br>contract C is A, B {  <br>    // Defining external function <br>    // to return state variable x<br>    function getStr() external returns(string memory) {  <br>        return x;  <br>    } <br>  <br>    // Defining external function <br>    // to return state variable pow<br>    function getPow() external returns(uint) {  <br>        return pow;  <br>    }  <br>}  <br><br>// Defining calling contract <br>contract caller {  <br>    // Creating object of contract C<br>    C contractC = new C();  <br>  <br>    // Defining public function to <br>    // return values from functions<br>    function testInheritance() public returns(string memory, uint) {  <br>        contractC.setA();  <br>        contractC.setB();  <br>        return (contractC.getStr(), contractC.getPow());  <br>    }  <br>}  </pre><p><strong>Key Concepts In Inheritance</strong></p><ul><li><strong>Inheritance Syntax:</strong> Use the is keyword to inherit from one or more base contracts, separated by commas for multiple inheritance.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>contract Child is Parent1, Parent2 { ... }   </pre><ul><li><strong>Virtual and Override: </strong>To enable function overriding in derived contracts, base functions must be marked virtual, and derived functions must use override.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>contract Animal {<br>    function makeSound() public virtual returns (string memory) {<br>        return &quot;Animal sound&quot;;<br>    }<br>}<br>contract Dog is Animal {<br>    function makeSound() public override returns (string memory) {<br>        return &quot;Bark&quot;;<br>    }<br>}   </pre><ul><li><strong>Calling Parent Functions:</strong> Use super.functionName() to invoke a function from the immediate parent contract in the inheritance hierarchy.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>function makeAnimalSound() public returns (string memory) {<br>    return super.makeSound(); // Calls Animal&#39;s makeSound<br>}   </pre><p><strong>Best Practices</strong></p><ul><li><strong>Avoid the Diamond Problem: </strong>Multiple inheritance can lead to ambiguity when a contract inherits the same member from multiple paths. Solidity resolves this using C3 Linearization, which defines a deterministic method resolution order (MRO) from left to right in the inheritance list.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>contract A {<br>    function foo() public pure virtual returns (string memory) {<br>        return &quot;A&quot;;<br>    }<br>}<br><br>contract B is A {<br>    function foo() public pure virtual override returns (string memory) {<br>        return &quot;B&quot;;<br>    }<br>}<br><br>contract C is A {<br>    function foo() public pure virtual override returns (string memory) {<br>        return &quot;C&quot;;<br>    }<br>}<br><br>contract D is B, C {<br>    function foo() public pure override(B, C) returns (string memory) {<br>        return super.foo();<br>    }<br>}</pre><p>Even though B is listed first, super.foo() calls the <strong>next in linearization</strong>, which ends up being C.</p><ul><li><strong>Use Abstract Contracts: </strong>Abstract contracts define functions but do not implement them. They enforce that child contracts must implement those functions. These help with enforcing structure, define required behavior, acts like blueprints and improve architecture clarity.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>abstract contract Animal {<br>    function speak() public pure virtual returns (string memory);<br>}<br><br>contract Dog is Animal {<br>    function speak() public pure override returns (string memory) {<br>        return &quot;Woof&quot;;<br>    }<br>}</pre><ul><li><strong>Minimize Deep Hierarchies:</strong> Deep inheritance chains can complicate code and increase deployment costs. Favor shallow, focused hierarchies.</li><li><strong>Combine with Libraries:</strong> Use libraries for stateless utility functions to reduce contract size and gas costs.</li></ul><pre>// SPDX-License-Identifier: UNLICENSED<br>pragma solidity ^0.8.13;<br><br>library MathLib {<br>    function add(uint a, uint b) internal pure returns (uint) {<br>        return a + b;<br>    }<br>}<br><br>contract Token {<br>    function calculate(uint x, uint y) public pure returns (uint) {<br>        return MathLib.add(x, y);<br>    }<br>}</pre><p>Inheritance in Solidity defines how contracts relate, how logic is layered, and how systems scale over time. When applied intentionally, inheritance enables modular design, reusable components, and clean separation of responsibilities. When applied carelessly, it introduces ambiguity, bloated bytecode, and fragile architecture. It gives developers the tools to write clean, maintainable code. By following best practices like using abstract contracts, avoiding deep hierarchies, and leveraging libraries, you can design systems that are not only powerful but also gas-efficient and easy to upgrade.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95ed7bdef0b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Who Gets Paid When NFTs Are Resold? Meet EIP-2981]]></title>
            <link>https://medium.com/@DolapoAjala/who-gets-paid-when-nfts-are-resold-meet-eip-2981-2dc16f0f48cc?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/2dc16f0f48cc</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[eip-2981]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Fri, 06 Feb 2026 14:42:36 GMT</pubDate>
            <atom:updated>2026-02-06T14:42:36.398Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/429/1*VI1nBVWfGM3vQwCaR7_b2Q.jpeg" /></figure><h3>The Backstory</h3><p>The rapid growth of NFTs introduced new ways for creators to monetize digital assets, but it also exposed a major gap: the lack of a standardized method for handling royalties on secondary sales. <strong>EIP-2981</strong> was introduced to solve this problem by providing a consistent, on-chain way for NFTs to declare royalty information. This article explores what EIP-2981 is, why it exists, how it works, and its role in the evolving NFT ecosystem.</p><h3>What Is an EIP?</h3><p>An <strong>Ethereum Improvement Proposal (EIP)</strong> is a design document that outlines new features, processes, or standards for Ethereum. EIPs provide technical specifications and rationale that help guide Ethereum’s development and ensure ecosystem-wide interoperability.</p><p>EIP-2981 falls under the category of <strong>ERC (Ethereum Request for Comments)</strong> standards, which define application-level interfaces used by smart contracts.</p><h3>What Is EIP-2981?</h3><p><strong>EIP-2981</strong>, also known as the <strong>NFT Royalty Standard</strong>, defines a common interface that allows NFT smart contracts to specify royalty payment information. It enables marketplaces and platforms to determine <strong>who should receive royalties and how much</strong>, particularly during secondary sales.</p><p>Importantly, EIP-2981 does <strong>not enforce royalty payments</strong>. Instead, it provides a standardized way to retrieve royalty details, leaving enforcement to marketplaces.</p><h3>Authors and Creation Date</h3><p><strong>EIP-2981</strong> was authored by Zach Burks, James Morgan, Blaine Malone, James Seibel.<br>It was officially created and proposed in <strong>September 2020</strong> and later finalized as an Ethereum standard.</p><h3>Motivation Behind EIP-2981</h3><p>Before EIP-2981, NFT royalties were handled inconsistently:</p><ul><li>Each marketplace implemented its own royalty logic</li><li>Some platforms ignored royalties entirely</li><li>Creators had no guarantee of earning from resales</li></ul><p>The motivation behind EIP-2981 was to:</p><ul><li>Create a <strong>universal royalty interface</strong></li><li>Improve <strong>interoperability</strong> across marketplaces</li><li>Reduce custom royalty implementations</li><li>Protect long-term creator incentives</li></ul><h3>How EIP-2981 Functions</h3><p>At its core, EIP-2981 introduces a single function:</p><pre>function royaltyInfo(<br>        uint256 _tokenId,<br>        uint256 _salePrice<br>    ) external view returns (<br>        address receiver,<br>        uint256 royaltyAmount<br>    );</pre><p>This function returns:</p><ul><li>The <strong>royalty receiver address</strong></li><li>The <strong>royalty amount</strong>, calculated as a portion of the sale price</li></ul><p>When an NFT is sold, a marketplace can call this function to determine how much royalty should be paid and to whom.</p><h3>Required Standards and Dependencies</h3><p>EIP-2981 is designed to work alongside existing NFT standards:</p><ul><li><strong>ERC-721</strong> (Non-Fungible Tokens)</li><li><strong>ERC-1155</strong> (Multi-Token Standard)</li></ul><p><strong>EIP-2981</strong> is not a standalone NFT standard; instead, it is designed to work alongside existing token standards, specifically <strong>ERC-721</strong> and <strong>ERC-1155</strong>. <strong>ERC-721</strong> defines the core structure for non-fungible tokens, where each token is unique and individually owned, while <strong>ERC-1155</strong> supports both fungible and non-fungible tokens within a single contract. <strong>EIP-2981</strong> extends these standards by introducing a unified way to expose royalty information without altering how tokens are minted, transferred, or owned. By building on top of <strong>ERC-721</strong> and <strong>ERC-1155 </strong>rather than replacing them, <strong>EIP-2981</strong> ensures backward compatibility and allows existing NFT contracts to adopt royalty support with minimal changes to their architecture.</p><h3>Understanding EIP-2981: Key Features for NFT Developers</h3><p>For developers, EIP-2981 offers several advantages:</p><ul><li><strong>Royalty Calculation:</strong> Standardized method (royaltyInfo) outlines how much and to whom a secondary sale royalty is paid, using a basis points system (e.g., 500 = 5%).</li><li><strong>Marketplace Compatibility:</strong> Uniform interface ensures proper royalty recognition on OpenSea, Rarible, and other major venues, boosting the author’s income reliability.</li><li><strong>Transparency:</strong> Royalty payout terms are publicly accessible via on-chain calls, fostering trust among artists, buyers, and platforms.</li><li><strong>Ease of Upgrade:</strong> Contracts can be extended to support future versions by following the same interface pattern, avoiding disruptive migrations.</li><li><strong>Interoperability:</strong> Adoption accelerates cross-platform recognition–consult standards and explore solutions before integrating additional market-specific royalty logic or off-chain workarounds.</li><li><strong>Reduced Disputes:</strong> Pre-defined, programmable royalty terms mitigate potential misunderstandings between creators, buyers, and resellers.</li></ul><h3>Mechanism and Implementation</h3><p>Implementing EIP-2981 typically involves:</p><ol><li>Defining royalty parameters (percentage and recipient)</li><li>Implementing the royaltyInfo function</li><li>Ensuring the contract declares support for the EIP-2981 interface</li></ol><p>Marketplaces then:</p><ul><li>Detect EIP-2981 support</li><li>Query royalty information during sales</li><li>Distribute royalties accordingly</li></ul><p>This separation of responsibility keeps contracts simple and marketplaces flexible.</p><h3>Comparing EIP-2981 to Other Royalty Standards</h3><p>Before EIP-2981, royalties were often:</p><ul><li>Hardcoded into marketplace contracts</li><li>Implemented using custom logic</li><li>Enforced off-chain</li></ul><p>Compared to these approaches, EIP-2981:</p><ul><li>Is on-chain and transparent</li><li>Works across multiple marketplaces</li><li>Reduces fragmentation in the NFT ecosystem</li></ul><p>However, unlike some proprietary systems, EIP-2981 does not force compliance.</p><h3>The Role of EIP-2981 in Enhancing Creator Revenue</h3><p>EIP-2981 empowers creators by:</p><ul><li>Making royalty expectations explicit</li><li>Encouraging marketplace compliance</li><li>Improving long-term revenue potential from secondary sales</li></ul><p>While it does not guarantee payment, it significantly raises the standard for how royalties are handled in NFTs.</p><h3>Practical Applications and the Future of EIP-2981</h3><p>Today, many major NFT marketplaces support EIP-2981, making it a de facto standard. As the NFT space matures, EIP-2981 is expected to:</p><ul><li>Influence Layer-2 NFT marketplaces</li><li>Integrate with cross-chain NFT standards</li><li>Serve as a foundation for more advanced creator-economy tools</li></ul><p>Its simplicity makes it well-positioned for long-term adoption.</p><h3>Challenges and Limitations of EIP-2981 Adoption</h3><p>Despite its benefits, EIP-2981 has limitations:</p><ul><li><strong>No enforcement:</strong> Marketplaces may ignore royalties</li><li><strong>Off-chain dependency:</strong> Actual payment logic lives outside the contract</li><li><strong>Inconsistent adoption:</strong> Not all platforms honor the standard equally</li></ul><p><strong>EIP-2981 </strong>represented an important step toward creating a fairer and more sustainable NFT ecosystem. By introducing a standardized, on-chain way to declare royalty information, it brought clarity and consistency to an area that was once fragmented and platform-dependent. Rather than enforcing royalties at the protocol level, <strong>EIP-2981</strong> strikes a careful balance, preserving Ethereum’s permissionless nature while giving creators a reliable way to signal how they should be compensated.</p><p>Although its effectiveness ultimately depends on marketplace adoption, <strong>EIP-2981</strong> has already become a foundational standard for NFTs on Ethereum. For developers, it offers interoperability with minimal complexity; for marketplaces, a clear royalty interface; and for creators, a stronger expectation of long-term value from their work. As the NFT space continues to evolve across Layer-2s and new ecosystems, <strong>EIP-2981</strong> stands as a quiet but critical building block in shaping a creator-friendly Web3 economy.</p><p>These challenges highlight the trade-off between decentralization and enforcement in open systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2dc16f0f48cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ethereum Under The Hood: Understanding Evm, Blocks, Gas, Accounts and Transactions]]></title>
            <link>https://medium.com/@DolapoAjala/ethereum-under-the-hood-understanding-evm-blocks-gas-accounts-and-transactions-1a2eb48ed2b3?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a2eb48ed2b3</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 11:57:53 GMT</pubDate>
            <atom:updated>2026-02-07T13:05:10.586Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is Ethereum?</h3><p>Ethereum is a decentralized blockchain and development platform powered by its native cryptocurrency, Ether (ETH). Since its launch in 2015, it has enabled developers to build and deploy smart contracts, making possible a wide range of decentralized applications (dApps) in areas like finance, gaming, and digital art. One of Ethereum’s defining characteristics is its proof-of-stake consensus model, which significantly lowers energy usage and computational demand. It also plays a central role in the Web3 movement, often described as the next evolution of the internet centered on decentralization and user ownership. Understanding how Ethereum<strong> </strong>functions internally requires a closer look at some concepts that power the network: the Ethereum Virtual Machine (EVM), block, gas, accounts, and transactions.</p><h3>Ethereum Virtual Machine (EVM)</h3><p>The <strong>Ethereum Virtual Machine (EVM)</strong> is a decentralized execution environment responsible for running smart contracts on the Ethereum network. It acts as the runtime layer for all Ethereum accounts and contract code, enabling developers to deploy applications that operate on-chain without relying on any central authority.</p><ul><li><strong>Decentralized Execution:</strong> The EVM runs across a distributed network of nodes, ensuring that contract execution is not controlled by any single participant.</li><li><strong>Quasi-Turing-Complete System:</strong> The EVM can perform any computation that can be algorithmically defined, provided sufficient computational resources are available.</li><li><strong>Smart Contract Processing:</strong> Once a smart contract is deployed, the EVM executes its logic in response to incoming transactions, applying changes to the blockchain’s state as defined by the contract.</li><li><strong>Gas-Based Resource Control:</strong> Every operation performed within the EVM consumes gas, which represents the cost of computation. Gas fees discourage misuse of network resources and incentivize validators to include transactions.</li><li><strong>Execution Isolation:</strong> Smart contracts run in isolated environments, ensuring that one contract’s execution cannot directly interfere with another.</li><li><strong>Global State Tracking:</strong> The EVM manages Ethereum’s global state by keeping track of all account balances, contract storage, and execution outcomes across the network.</li></ul><p><strong>How it works</strong></p><p>The Ethereum Virtual Machine (EVM) functions by executing smart contracts that are written in high-level languages, compiled into bytecode, and deployed to the network through transactions. Users interact with these contracts by submitting transactions, which are executed independently by each node’s EVM to update Ethereum’s global state. Every operation consumes gas, and transactions that run out of gas are reverted while still incurring costs. Executed transactions are validated, bundled into blocks by validators, and permanently recorded on the blockchain.</p><h3>Blocks</h3><p>In Ethereum, a block is a collection of transactions and other data that are added to the Ethereum blockchain. Each block contains a unique code called a “hash” that allows it to be distinguished from every other block, as well as a “hash” of the previous block in the chain, linking the two. Any alteration to a past block, changes its hash immediately breaking the chain and making tampering detectable across the network.</p><p>A block in Ethereum is composed of two main parts: the <strong>block header</strong> and the <strong>block body</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/495/1*4TFCO34aNEWszjRvMMAlzA.png" /><figcaption><a href="https://www.geeksforgeeks.org/computer-networks/ethereum-block-structure/">Ethereum Block Structure — GeeksforGeeks</a></figcaption></figure><p><strong>1. Block Header</strong><br> An Ethereum block header contains key information about the block, validator, and network state:</p><ul><li><strong>Parent Hash:</strong> Links to the previous block, ensuring blockchain integrity.</li><li><strong>State Root:</strong> Hash summarizing the current network state, including account balances and contract storage.</li><li><strong>Transaction Root:</strong> Hash summarizing all transactions in the block for verification.</li><li><strong>Receipts Root:</strong> Hash summarizing transaction outcomes, including gas used and contract addresses.</li><li><strong>Gas Limit:</strong> Maximum gas allowed for all transactions in the block.</li><li><strong>Gas Used:</strong> Total gas consumed by all transactions in the block.</li><li><strong>Timestamp:</strong> The time the block was proposed.</li><li><strong>Extra Data:</strong> Arbitrary data added by the block producer.</li></ul><p><strong>2. Block Body</strong></p><p>It holds all the information needed to process the block’s transactions. Its main elements are :</p><ul><li><strong>List of Transactions:</strong> Contains all transactions in the block, including details like sender, recipient, amount, and other relevant data.</li><li><strong>List of Uncle (Ommer) Blocks:</strong> Records valid blocks not included in the main chain, helping reduce network congestion and providing rewards to miners for referencing them.</li></ul><h3>Gas</h3><p>Gas fees on Ethereum measure the computational effort and resources needed to process a transaction or run a smart contract. Every operation, like sending funds or executing a function, consumes a certain amount of gas. These fees motivate miners to prioritize higher-fee transactions and help maintain network efficiency by deterring spam and malicious activity. This fee must be paid whether the transaction succeeds or fails.</p><p><strong>Calculating Gas Fees in Ethereum</strong><br> Originally, Ethereum gas fees were based on the gas limit and the price per unit of gas. Since August 2021, the calculation includes a <strong>base fee</strong> (set by the network), the <strong>units of gas used</strong>, and a <strong>priority fee</strong> (a tip to incentivize validators to process the transaction faster).</p><p>The formula for gas fees is:</p><p><strong>Gas Fee = Units of Gas Used × (Base Fee + Priority Fee)</strong></p><p>For example, sending 1 ETH that requires 21,000 units of gas with a base fee of 11 gwei and a priority fee of 3 gwei results in:</p><p>21,000 × (11 + 3) = 294,000 gwei = 0.000294 ETH</p><p>This is added to the transfer, making the total 1.000294 ETH.</p><h4><strong>Fa</strong>ctors Influencing Gas Fees and Their Role in High Fees</h4><p>High gas fees usually result from a combination of network congestion and high demand, often exacerbated by inefficient contracts. Even if the base fee is moderate, a complex transaction or a congested network can make fees spike significantly. Efficient contract design and timing transactions during low network activity can help reduce the impact of high gas fees. Several factors contribute to high gas fees:</p><ol><li><strong>Network Congestion:</strong><br> When many users submit transactions simultaneously, the network can become congested. Ethereum’s block size and processing capacity are limited, so validators prioritize transactions that pay higher fees. This competition drives up the gas price, resulting in higher transaction costs.</li><li><strong>Gas Price Trends:</strong><br> Gas prices are influenced by market dynamics and user demand. Users willing to pay higher fees can get their transactions processed faster. During periods of high demand, even routine transactions can become expensive because the “market price” of gas rises.</li><li><strong>Gas Limit Optimization:</strong><br> The efficiency of smart contracts affects gas consumption. Poorly optimized contracts require more computational work per transaction, increasing the gas used and, therefore, the total fee. Developers who optimize their contracts reduce the amount of gas each transaction consumes, helping to mitigate high fees.</li></ol><h3>Account</h3><p>An account is the digital identity for users and smart contracts in the world of Ethereum. They are essential for interacting with the blockchain, and they come in two main forms: Externally Owned Accounts (EOAs) and Contract Accounts.</p><h4>1. Externally Owned Accounts (EOAs)</h4><p>EOAs are controlled by private keys and typically belong to individuals or organizations. They are essential for everyday transactions on Ethereum.</p><p><strong>Key Features:</strong></p><ul><li><strong>Address:</strong> A unique 42-character hexadecimal identifier (e.g., 0x09e…5d).</li><li><strong>Private Key:</strong> A secret key used to sign transactions and prove account ownership; must be kept secure.</li><li><strong>Nonce:</strong> Tracks the number of transactions sent to ensure proper order and prevent replay attacks.</li><li><strong>Functionality:</strong> Can send ETH, interact with contracts and dApps.</li></ul><h4>2. Contract Accounts</h4><p>Contract accounts are governed by smart contract code instead of private keys. They enable automated functions and interactions on Ethereum.</p><p><strong>Key Features:</strong></p><ul><li><strong>Address:</strong> Unique 42-character hexadecimal identifier like EOAs.</li><li><strong>Smart Contract Code:</strong> Defines the contract’s behavior and interactions with other accounts.</li><li><strong>Function Execution:</strong> Automatically executes predefined functions when certain conditions are met.</li><li><strong>State Management:</strong> Stores and manages internal data to interact with EOAs or other contracts.</li></ul><h4>Ethereum Account Structure</h4><p>Ethereum accounts store essential information for transactions and smart contract interactions. Key components include:</p><ul><li><strong>Address:</strong> A unique 42-character identifier (starts with 0x) used to send/receive ETH and interact with contracts.</li><li><strong>Public Key:</strong> Derived from the private key, used to verify signatures and identify the account.</li><li><strong>Private Key:</strong> A 64-character secret key controlling the account and signing transactions; must be securely managed.</li><li><strong>Balance:</strong> Amount of ETH held, stored in Wei (1 ETH = 1¹⁸ Wei).</li><li><strong>Nonce:</strong> Counts transactions sent from the account to ensure correct order and prevent replay attacks.</li><li><strong>Contract Code (for Contract Account):</strong> Bytecode defining the contract’s logic, executed when functions are called.</li><li><strong>Storage (for Contract Account):</strong> Key-value store maintaining the contract’s internal state.</li><li><strong>Code Hash (for Contract Account):</strong> 32-byte hash of the contract’s bytecode, used for verification.</li></ul><h3>Transactions</h3><p>In Ethereum, a transaction is an action that transfers value or information from one account to another. Transactions are the fundamental mechanism for updating the blockchain’s state and interacting with smart contracts.</p><h4>Understanding Ethereum Transactions</h4><p>A transaction in Ethereum is an action initiated by an account that changes the state of the blockchain. Transactions fall into three main types:</p><ol><li><strong>Regular Transactions:</strong> Transfer Ether or tokens between accounts, commonly used for payments often referred to as payment transactions.</li><li><strong>Contract Creation Transactions:</strong> It contains code to deploy new smart contracts and do not include a recipient address.</li><li><strong>Message Calls:</strong> They interact with existing smart contracts, triggering functions without necessarily transferring funds.</li></ol><h4>Transaction Architecture</h4><p>The transaction format for Ethereum was originally one standard but has evolved over time to allow other transaction formats. The set of instructions in a transaction object looks like this:</p><ul><li><strong>from </strong>- the sending address.</li><li><strong>to </strong>– the receiving address (if EOA, the transaction will transfer value. If a smart contract account, the transaction will use contract code).</li><li><strong>value</strong> – the amount of ETH to be sent from the sending address (denominated in Wei)</li><li><strong>data </strong>– can contain code or a message to the recipient.</li><li><strong>gasLimit </strong>– the maximum amount of gas units that can be used.</li><li><strong>nonce </strong>- a number used to track ordering of transactions and prevent replay attacks</li><li><strong>maxPriorityFeePerGas </strong>- the maximum amount of gas to be included as a tip to the miner.</li><li><strong>maxFeePerGas </strong>- the maximum amount of gas willing to be paid for the transaction (including baseFeePerGas and maxPriorityFeePerGas).</li><li><strong>signature </strong>– derived from the sending account&#39;s private key and is created when the sender signs the transaction.</li></ul><p>Ethereum’s architecture is a finely balanced ecosystem where accounts,<strong> </strong>blocks,<strong> </strong>gas, transactions, and the EVM work together to maintain a secure, decentralized, and programmable blockchain. Together, these elements create a robust, programmable, and secure blockchain ecosystem. Ethereum is not just a platform for transferring value, it is a dynamic foundation for decentralized innovation, powering applications that is already reshaping finance, governance, and digital interaction on a global scale.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a2eb48ed2b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ethereum’s Evolution: How Network Upgrades Forged the World’s Leading Blockchain]]></title>
            <link>https://medium.com/@DolapoAjala/ethereums-evolution-how-network-upgrades-forged-the-world-s-leading-blockchain-460be6628cb5?source=rss-5029937e6057------2</link>
            <guid isPermaLink="false">https://medium.com/p/460be6628cb5</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Dolapo Ajala]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 11:42:51 GMT</pubDate>
            <atom:updated>2026-02-05T06:36:34.737Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DEZ3xzmDMiaPnxEtje0IFg.avif" /></figure><p>10 years</p><p>17 Network upgrades</p><p>Zero Downtime</p><p>Over the last decade, Ethereum has transitioned from a smart contract experiment to the foundational coordination layer for an entirely new class of financial and governance systems. Each upgrade, from Byzantium to Fusaka, reflects more than a technical change. It represents a deliberate shift in how the protocol thinks about execution, security, and decentralization.</p><p>Ethereum is no longer a monolithic blockchain. It’s a modular trust infrastructure powering rollups, AVSs (Actively Validated Services), and increasingly, real-world use cases.</p><h3>2013–2014: The Whitepaper and Early Vision</h3><p>In late 2013, Vitalik Buterin, a programmer and early contributor to the Bitcoin ecosystem, published a whitepaper that introduced a fundamental shift in blockchain design: a general-purpose platform that could run arbitrary programs on-chain (Turing-complete scripting language).</p><p>Unlike Bitcoin’s limited scripting language, Ethereum would allow developers to deploy trustless applications directly on the base layer.</p><p>The idea quickly attracted a group of early contributors who formalized the roadmap and worked to turn the concept into a live protocol.</p><p>In April 2014, Gavin Wood released the Yellow Paper, which provided the first formal specification of the Ethereum Virtual Machine (EVM).</p><p>A public crowd sale later that year raised approximately $18M in BTC, the largest open-source protocol fundraising at the time and created early alignment between token holders, developers, and the network’s long-term success.</p><p><strong>Why This Phase Was Crucial</strong></p><ul><li>Introduced the concept of a general-purpose blockchain.</li><li>Formalized the EVM as the core execution engine for decentralized applications.</li><li>Demonstrated a new funding model for open-source infrastructure projects.</li></ul><p>With the core vision established and early supporters aligned, the next challenge was turning the concept into a functioning network. That shift from theoretical design to live execution began with the Genesis Launch.</p><h3>2015: Olympic (Extreme Stress-Testing Before Launch)</h3><p>In 2015, prior to its official debut, the Ethereum community introduced Olympic, the ecosystem’s final public testnet. Rather than a standard rehearsal, Olympic was an intentional “stress test” where developers were invited to push the network to its breaking point. To ensure no stone was left unturned, the Ethereum Foundation offered a massive 25,000 ETH bounty for identifying bugs, performance bottlenecks, or security flaws.</p><p><strong>The Impact of Olympic</strong><br>This phase acted as a trial by fire for the Ethereum Virtual Machine (EVM), uncovering several critical issues:</p><ul><li><strong>Security Gaps:</strong> It highlighted significant Denial of Service (DoS) vulnerabilities and flaws in the initial gas pricing model.</li><li><strong>Software Discrepancies:</strong> The test revealed inconsistencies between different client implementations, proving that a more unified protocol specification was necessary.</li><li><strong>Proven Resilience:</strong> By surviving these coordinated “attacks,” Ethereum proved it could function in a live, adversarial environment.</li></ul><p>Ultimately, the lessons learned during Olympic provided the technical foundation and confidence required to move forward with Frontier, Ethereum’s first official mainnet release.</p><h3>2015: Frontier (Ethereum’s First Live Network)</h3><p>Ethereum on <strong>July 30, 2015</strong>, officially moved beyond experimentation with the launch of Frontier, its first public mainnet. This milestone marked the birth of the Ethereum blockchain, beginning with a “genesis block” that distributed ETH to the 8,000+ participants of the 2014 presale.</p><p>Frontier was a minimalist, “live beta” version of the network specifically tailored for developers and miners rather than the general public. Its technical architecture was defined by several foundational elements:</p><ul><li><strong>Proof of Work (PoW) Consensus</strong> using the <strong>Ethash </strong>algorithm, with miners securing the network by solving cryptographic puzzles and earning 5 ETH per block.</li><li><strong>Ethereum Virtual Machine (EVM)</strong> operational and ready to execute smart contracts.</li><li>A deliberately simple feature set and a <strong>difficulty bomb</strong> (later called the “Ice Age”), designed to slowly make mining harder to incentivize a future switch to a new consensus mechanism.</li></ul><p>To manage the risks of this early stage, the protocol included centralized “canary contracts” that could halt the chain in an emergency, as a formal Ethereum Improvement Proposal (EIP) process did not yet exist.</p><p>The Genesis phase didn’t just mark the beginning of the network; it established the pattern that still defines Ethereum today: <strong>ship early → observe under real conditions → evolve the protocol accordingly</strong>.</p><h3>2016: Homestead</h3><p>By March 2016, Ethereum had proven it could support genuine economic activity, with ETH appearing on exchanges and developers launching functional contracts. This growth necessitated a shift toward a more stable, production-ready environment, leading to the <strong>Homestead</strong> upgrade on March 14, 2016. This milestone signaled a new era of maturity for the protocol by removing the “canary contract” safety nets that had characterized the Frontier era. Beyond technical stability, Homestead introduced the formal Ethereum Improvement Proposal (EIP) system, a standardized governance framework that allowed the community to transparently propose and debate protocol changes, a process that remains the heartbeat of Ethereum’s evolution today.</p><p><strong>Technical Upgrades (Core EIPs)</strong></p><ul><li><strong>EIP-2:</strong> Refined the difficulty adjustment algorithm and increased gas costs for contract creation to bolster economic security and prevent spam.</li><li><strong>EIP-7 (DELEGATECALL):</strong> Introduced a vital opcode that allowed contracts to execute code from other contracts while maintaining the original transaction context, paving the way for modular and upgradeable contract architecture.</li><li><strong>EIP-8:</strong> Updated network protocol compatibility to ensure that future software upgrades would be smoother and more predictable.</li></ul><h3>2016: The DAO Hack and the Hard Fork (Governance Under Stress)</h3><p>In April 2016, a new decentralized entity known as <strong>The DAO </strong>launched on the Ethereum network. Conceived as a pioneering experiment in autonomous governance, it successfully raised a massive amount of ETH through its crowdsale. However, a significant <strong>smart contract vulnerability</strong> allowed an attacker to drain approximately <strong>3.6 million ETH,</strong> which represented tens of millions of dollars at the time.</p><p><strong>The impact was immediate:</strong></p><ul><li>ETH price dropped ~50% within days.</li><li>Community split into two camps: <strong>“code is law”</strong> (no intervention) vs <strong>“restore the stolen funds”</strong> (fork the network).</li><li>After extensive debate, the network adopted a hard fork, returning the stolen ETH and creating a clean state.</li></ul><p><strong>The Great Debate and Fork</strong><br>The theft presented the Ethereum community with a fundamental existential crisis regarding whether the protocol should stay immutable or intervene to recover the funds. This led to a controversial hard fork in July 2016:</p><ul><li><strong>Ethereum (ETH):</strong> This group chose to adopt the fork, effectively rolling back the theft and returning the ETH to the original owners.</li><li><strong>Ethereum Classic (ETC):</strong> This group remained on the original, unforked chain, adhering to the principle that “code is law” and the blockchain should remain immutable.</li></ul><p>The DAO fork established a major precedent for <strong>social consensus</strong> in blockchain governance. It demonstrated that, in extreme situations, the collective agreement of the community could override technical immutability to protect the network’s stakeholders.</p><h3>2017: Metropolis Part 1 Byzantium (Cryptography, Safety, and Efficiency)</h3><p>As Ethereum usage continued to expand, the community initiated the <strong>Metropolis </strong>era to prepare the network for mass adoption and the eventual transition to <strong>Proof of Stake (PoS)</strong>. The first phase of this era, known as <strong>Byzantium</strong>, launched on October 16, 2017. Its primary mission was to bolster security, improve performance, and integrate advanced privacy features.</p><p><strong>Key objectives of Byzantium were:</strong></p><ul><li>Increase smart contract safety and resilience.</li><li>Add advanced cryptographic capabilities.</li><li>Reduce block rewards to slow issuance ahead of PoS research.</li></ul><p><strong>Essential EIPs in Byzantium included:</strong></p><ul><li><strong>EIP 140 (REVERT):</strong> Allowed contracts to abort with error messages and refund unused gas, greatly improving error handling.</li><li><strong>EIP 196 &amp; EIP 197:</strong> Added precompiled elliptic curve cryptography operations, enabling efficient verification of zk-SNARKs and other advanced protocols.</li><li><strong>EIP 211 &amp; EIP 214:</strong> Introduced opcodes enhancing EVM functionality and security.</li><li><strong>EIP 649:</strong> Delayed the difficulty bomb and reduced block rewards from 5 ETH to 3 ETH.</li><li><strong>EIP 658:</strong> Included transaction status codes in receipts, making it easier to detect success or failure.</li></ul><p>Byzantium successfully established the cryptographic and functional foundations necessary for advanced privacy features and more complex decentralized applications. By slightly reducing miner incentives and adjusting the difficulty bomb, it served as a critical stepping stone toward Ethereum’s long-term protocol evolution.</p><h3>2019: Metropolis Part 2 (Constantinople &amp; Petersburg)</h3><p>The second stage of the Metropolis era arrived on <strong>February 28, 2019,</strong> through the <strong>Constantinople</strong> upgrade. It was launched alongside a companion fix known as <strong>Petersburg</strong>, which was specifically designed to remove a problematic proposal (EIP-1283) that had shown vulnerabilities during the final testing phases. Together, these upgrades focused on refining the network’s efficiency and economic structure.</p><p><strong>Highlights included:</strong></p><ul><li><strong>EIP 1014 (CREATE2):</strong> Allowed contracts to be precomputed at predictable addresses, unlocking important capabilities for state channels and Layer 2 solutions.</li><li><strong>EIP 1052 &amp; EIP 1283:</strong> Optimized contract execution and introduced more efficient storage pricing.</li><li><strong>EIP 1234:</strong> Reduced block rewards again from 3 ETH to 2 ETH and pushed the difficulty bomb.</li></ul><h3>2019–2020: Istanbul &amp; Muir Glacier (Preparing for Rollups and Long-Term Survival)</h3><p>As transaction volume and Layer-2 innovation accelerated, Ethereum underwent the <strong>Istanbul</strong> upgrade in December 2019 to better support scaling solutions and maintain network usability. This update focused on optimizing cryptographic operations and adjusting gas costs to reflect actual computational effort, which helped defend against spam attacks. Most importantly, Istanbul significantly reduced the cost of <strong>calldata</strong>, a technical change that was vital for the economic viability of rollups, as it made storing data on the main chain much cheaper for these scaling protocols.</p><p>Shortly after, in January 2020, the <strong>Muir Glacier</strong> upgrade was deployed to address a single pressing issue. It implemented <strong>EIP-2384</strong> to once again delay the “difficulty bomb,” which had begun to slow down block production. By pushing back this mechanism, developers ensured the network remained fast and responsive. Together, Istanbul and Muir Glacier allowed Ethereum to sustain heavy workloads while providing the necessary breathing room for the long-term transition toward Proof of Stake.</p><h3>2021: Berlin &amp; London (Securing Gas Economics and Fee Reform)</h3><p>As Ethereum’s network usage surged, developers turned their attention to refining gas pricing and eliminating persistent security vulnerabilities.</p><h3>The Berlin Upgrade (April 2021)</h3><p>The <strong>Berlin</strong> upgrade focused on hardening the network against Denial-of-Service (DoS) attacks and improving how the Ethereum Virtual Machine (EVM) handles state access.</p><ul><li><strong>EIP-2929:</strong> This proposal increased the gas cost for “cold” (first-time) state accesses, effectively closing off vectors that attackers could use to spam and slow down the network.</li><li><strong>EIP-2930:</strong> It introduced “access lists,” allowing users to pre-specify which addresses and keys their transactions would interact with, resulting in more predictable gas costs.</li></ul><h3>The London Upgrade (August 2021)</h3><p>A few months later, the <strong>London</strong> upgrade introduced <strong>EIP-1559</strong>, one of the most significant shifts in Ethereum’s economic history. This move replaced the old “blind auction” fee model with a more sophisticated system designed to improve the user experience and the asset’s scarcity.</p><ul><li><strong>Base Fee and Burning:</strong> The protocol now sets a mandatory “base fee” that fluctuates automatically based on network demand. Crucially, this fee is <strong>burned</strong> (permanently removed from circulation), which introduces deflationary pressure on the ETH supply.</li><li><strong>Priority Tips:</strong> Users can still add an optional “tip” to incentivize validators to prioritize their transactions during periods of high congestion.</li><li><strong>Predictability:</strong> By moving away from bidding wars, EIP-1559 made fee estimation much more reliable for wallets and end-users.</li></ul><h3>2022: The Merge (Transition to Proof of Stake)</h3><p>On <strong>15 September 2022</strong>, Ethereum completed one of the most ambitious protocol upgrades in blockchain history: <strong>The Merge</strong>.</p><p>After running in parallel with the Beacon Chain for nearly two years, the network transitioned from <strong>Proof of Work (PoW) to Proof of Stake (PoS)</strong>, combining the execution layer and consensus layer into a single PoS-based system.</p><p>Unlike previous upgrades, The Merge did not add new functionality or improve throughput. Its purpose was structural.</p><p><strong>Why the Transition Mattered</strong></p><ul><li><strong>Energy Efficiency:</strong> Ethereum’s energy consumption dropped by ~99.95%, immediately addressing one of the most common criticisms of public blockchains.</li><li><strong>Validator-Based Security Model:</strong> Block production shifted from hash power to stake-weighted participation. More than 400,000 validators now secure the network, making attacks economically expensive and aligning incentives around long-term network health.</li><li><strong>Execution Layer / Consensus Layer Separation:</strong> The Merge introduced a permanent architectural separation between the execution layer (EVM) and consensus layer, creating the foundation for future modular upgrades such as proto-danksharding (EIP-4844) and full data sharding.</li></ul><p>This upgrade also demonstrated something rarely seen at this scale:<strong> a live blockchain changed its consensus mechanism without any downtime or network reset.</strong></p><p>That success significantly increased institutional confidence and reinforced Ethereum’s position as the most adaptable base layer in Web3.With the consensus foundation secured, the ecosystem shifted its focus toward a new priority: modularity and rollup-centric scalability.</p><h3>2023–2024: Shapella, Dencun and the Rollup Era</h3><p>Once the transition to Proof of Stake was stabilized, Ethereum’s development shifted toward enhancing the user experience and long-term scalability. This era addressed the final pieces of the staking puzzle and provided the technical infrastructure needed for mass-market adoption via Layer-2 solutions.</p><h3>Shapella: Completing the Staking Cycle (April 2023)</h3><p>The <strong>Shapella</strong> upgrade (a combination of the Shanghai and Capella updates) was a landmark moment for the network’s security model.</p><ul><li><strong>Staked ETH Withdrawals:</strong> For the first time, users who had locked their ETH in the Beacon Chain were able to withdraw their principal and rewards.</li><li><strong>Reduced Risk:</strong> By enabling liquidity for stakers, the upgrade significantly lowered the perceived risk of participating in the network’s security, leading to a more robust and diverse set of validators.</li></ul><h3>Dencun: The Dawn of Blobs (March 2024)</h3><p>Following Shapella, the <strong>Dencun</strong> upgrade introduced <strong>EIP-4844,</strong> also known as <strong>Proto-Danksharding</strong>. This was arguably the most significant technical leap for scaling since the network’s inception.</p><ul><li><strong>Introduction of “Blobs”:</strong> Dencun created a new, temporary storage space on the blockchain called “binary large objects” (blobs).</li><li><strong>Lowering Layer-2 Costs:</strong> Blobs allow Layer-2 rollups to store transaction data on the mainnet for a fraction of the previous cost. Because this data is temporary and doesn’t stay on the blockchain forever, it avoids bloating the network while drastically reducing gas fees for end-users on platforms like Arbitrum, Optimism, and Base.</li></ul><p><strong>The Rollup-Centric Future</strong><br>The success of these upgrades has solidified Ethereum’s rollup-centric roadmap. In this model, the Ethereum mainnet acts as a highly secure layer for settlement and data availability, while the actual execution of transactions — and the high throughput required for apps and games — is handled off-chain by rollups.</p><h3>2025: Pectra (Usability, Flexibility and Staking Improvements)</h3><p>On <strong>May 7, 2025</strong>, the <strong>Pectra</strong> upgrade (a merger of the Prague and Electra updates) was activated, focusing heavily on refining the user experience and providing greater flexibility for network validators. This upgrade represented a significant push toward making Ethereum more accessible for mainstream users and more efficient for institutional stakers.</p><p><strong>Pectra’s Key Enhancements</strong></p><ul><li><strong>EIP-7702 (Account Abstraction Lite):</strong> This highly anticipated proposal revolutionized how standard wallets (Externally Owned Accounts or EOAs) function. It essentially gave regular accounts “smart contract superpowers” temporarily, enabling features like gas sponsorship (where someone else pays your transaction fee) and transaction batching (signing multiple actions at once). This effectively bridged the gap between basic wallets and advanced smart contract wallets.</li><li><strong>EIP-7251 (MaxEB):</strong> This changed the staking landscape by increasing the maximum effective validator balance from 32 ETH to 2,048 ETH. This allowed large-scale stakers to consolidate their many small validators into fewer, larger ones, significantly reducing the messaging overhead on the network and simplifying operations for institutional participants.</li><li><strong>EIP-7002 (Execution-Layer Triggered Exits):</strong> This added a layer of safety and simplicity for stakers by allowing withdrawal and exit requests to be triggered directly from the execution layer. This gave stakers more control and reduced the complexity involved in managing their exits from the consensus layer.</li></ul><h3>2025: Fusaka (Scaling for Future)</h3><p>The most recent milestone, <strong>Fusaka</strong>, was activated on <strong>December 3, 2025,</strong> marking a major leap in Ethereum’s scaling capabilities. The name is a blend of <strong>Osaka</strong> (execution layer) and <strong>Fulu </strong>(consensus layer), reflecting the coordinated nature of modern network upgrades.</p><p><strong>Fusaka: Scaling Through PeerDAS</strong></p><ul><li><strong>Peer Data Availability Sampling (EIP-7594):</strong> This is the upgrade’s flagship feature. It allows nodes to verify large “blobs” of data from Layer-2 rollups by sampling small pieces rather than downloading the entire file.</li><li><strong>Massive Capacity Increase:</strong> By reducing the data burden on individual validators, PeerDAS significantly increases blob throughput. This allows Layer-2s to process more transactions at even lower costs, solidifying Ethereum as a high-capacity settlement layer.</li><li><strong>Performance Tuning:</strong> The upgrade also included optimizations for gas limits and execution parameters, ensuring the network remains secure as it handles heavier data loads.</li></ul><h3>The 2026 Roadmap</h3><h3>Glamsterdam &amp; Hegota</h3><p><strong>Glamsterdam</strong> is the code name for Ethereum’s major hard fork scheduled for the <strong>first half of 2026.</strong> Following the activation of Fusaka in late 2025, Glamsterdam continues the network’s strategic shift toward a faster, biannual upgrade cadence. It focuses on two “headliner” improvements — one for the Consensus Layer and one for the Execution Layer — designed to boost speed, decentralization, and institutional-grade security.</p><p><strong>Core Headliner Features</strong></p><ul><li><strong>Enshrined Proposer-Builder Separation (ePBS — EIP-7732):</strong> This upgrade moves the block-building process directly into the Ethereum protocol. Currently, most validators rely on external “relays” (like MEV-Boost) to build profitable blocks. ePBS removes this third-party reliance, reducing censorship risks and making the network more “credibly neutral” by decentralizing how blocks are created and proposed.</li><li><strong>Block-Level Access Lists (BALs — EIP-7928):</strong> This is a structural shift in how transactions are processed. BALs allow a block to declare in advance which accounts and smart-contract data it will access. By providing this “roadmap” of data dependencies, nodes can switch from sequential processing to parallel execution, significantly increasing transaction throughput and paving the way for lighter, faster clients.</li></ul><h3>Hegota</h3><p><strong>Hegota</strong> is the second major fork of 2026, named by combining <strong>Heze </strong>(Consensus) and <strong>Bogotá </strong>(Execution). It addresses the “state bloat” problem — the ever-growing size of the Ethereum database.</p><ul><li><strong>Verkle Trees (The Headliner):</strong> This replaces the current data structure (Merkle Patricia Tries) with Verkle Trees.</li><li><strong>Tiny Proofs:</strong> It reduces the size of cryptographic proofs (witnesses) by roughly 100x.</li><li><strong>Statelessness:</strong> These tiny proofs allow “weak statelessness,” where nodes can verify blocks without needing to store the entire 200GB+ state on their local disks.</li><li><strong>State &amp; History Expiry:</strong> This mechanism allows nodes to stop serving and storing old historical data (older than ~1 year) locally. Old data is moved to “out-of-protocol” storage (like torrents or the Portal Network), keeping the active node footprint small and manageable.</li><li><strong>Hardware Democratization:</strong> By drastically lowering storage and RAM requirements, Hegota aims to make running a full Ethereum node possible on low-power devices like a Raspberry Pi or even a smartphone.</li></ul><p>Ethereum’s rise as a leading blockchain is not the result of a single breakthrough, but a decade-long commitment to deliberate and resilient evolution. Through carefully executed upgrades, Ethereum has proven that a decentralized network can adapt at scale enhancing security, improving efficiency, and embracing sustainability without compromising its core principles.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=460be6628cb5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>