<?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[Zellular - Medium]]></title>
        <description><![CDATA[Develop sub-second finality, high-throughput dapps, in any programming language. - Medium]]></description>
        <link>https://medium.com/zellular?source=rss----a4d57653d15a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Zellular - Medium</title>
            <link>https://medium.com/zellular?source=rss----a4d57653d15a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 08:17:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/zellular" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Hosting a Token as a Verifiable Service on EigenLayer]]></title>
            <link>https://medium.com/zellular/hosting-a-token-as-a-verifiable-service-on-eigenlayer-2ecf093615c7?source=rss----a4d57653d15a---4</link>
            <guid isPermaLink="false">https://medium.com/p/2ecf093615c7</guid>
            <category><![CDATA[tokenization]]></category>
            <category><![CDATA[zellular]]></category>
            <category><![CDATA[eigenlayer]]></category>
            <category><![CDATA[bft]]></category>
            <category><![CDATA[token]]></category>
            <dc:creator><![CDATA[PASLAR]]></dc:creator>
            <pubDate>Tue, 11 Mar 2025 10:54:38 GMT</pubDate>
            <atom:updated>2025-03-24T11:42:21.576Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaR-jmJbpPw1WgIVdwkRlQ.jpeg" /></figure><p>EigenLayer’s Autonomous Verifiable Services (AVSs) are often seen as extensions of blockchain smart contracts, expanding their capabilities. However, Zellular challenges this view, asserting that <strong>EigenLayer services are not just extensions of blockchain smart contracts but a next-generation evolution of them. Any smart contract can be transformed into a more efficient, verifiable service running on EigenLayer</strong>. To illustrate this, we’ll take one of the simplest smart contract implementations — a token — and demonstrate how it can function as a verifiable service on EigenLayer.</p><p>By the end of this guide, you’ll learn how to transform a centralized service, like a token, into a <strong>decentralized</strong> one on EigenLayer by:</p><p>✅ Replacing session-based authentication with <strong>signature-based authentication</strong><br>✅ Replicating the service in a way that ensures all nodes maintain a <strong>consistent state</strong><br>✅ Using signature aggregation to make the replicated service <strong>verifiable</strong></p><p>Let’s dive in.</p><h3>From a Centralized Token Service to a Decentralized AVS</h3><p>Before we implement a token as a decentralized service, let’s first imagine how its centralized equivalent looks like. A <strong>basic token service</strong> maintains a mapping of user balances and exposes two essential API methods:</p><p>1️⃣ <strong>A <em>POST</em> method to <em>transfer</em> tokens between users<br></strong>2️⃣ <strong>A <em>GET </em>method to check a user’s <em>balance</em></strong></p><p>In a traditional centralized setup, this service runs on a single server. A simple implementation of the above routes using FastAPI might look like this:</p><pre>@app.post(&quot;/transfer&quot;)<br>async def transfer(request: Request, data: TransferRequest):<br>    &quot;&quot;&quot;Transfer funds between users.&quot;&quot;&quot;<br>    username = request.session.get(&quot;username&quot;)<br>    if not username:<br>        raise HTTPException(status_code=401, detail=&quot;Unauthorized&quot;)<br><br>    if balances.get(username, 0) &lt; data.amount:<br>        raise HTTPException(status_code=400, detail=&quot;Insufficient balance&quot;)<br><br>    balances[username] -= data.amount<br>    balances[data.receiver] = balances.get(data.receiver, 0) + data.amount<br>    return JSONResponse({&quot;message&quot;: &quot;Transfer successful&quot;})<br><br>@app.get(&quot;/balance&quot;)<br>async def balance(username: str) -&gt; Dict[str, Any]:<br>    &quot;&quot;&quot;Retrieve user balance.&quot;&quot;&quot;<br>    return {&quot;username&quot;: username, &quot;balance&quot;: balances.get(username, 0)}</pre><h4>Why This Model Falls Short</h4><p>While simple and efficient, this centralized approach has critical limitations:</p><p>⚠️ <strong>Single point of failure</strong> — If the server goes down, the token service becomes inaccessible.<br>⚠️ <strong>Trust-based model</strong> — Users must trust the service provider to maintain accurate balances.<br>⚠️ <strong>Lack of verifiability</strong> — There’s no cryptographic proof that balances are correct.</p><p>To address these issues, we will <strong>transform this service into a verifiable service that can be hosted on EigenLayer using Zellular.</strong></p><h3>1. Verifiable Authentication with Signatures</h3><p>The first step in making our token service verifiable is using <strong>signature-based authentication </strong>instead of traditional session-based authentication. With this approach, users sign their transfer requests with their private key, and <strong>any network node can verify the request’s authenticity without needing access to private credentials </strong>hosted by a central authority<strong>.</strong></p><p>Here’s how we update our FastAPI-based token service to use signature-based authentication:</p><pre>from eth_account import Account<br>from eth_account.messages import encode_defunct<br><br>def verify_signature(sender: str, message: str, signature: str) -&gt; bool:<br>    &quot;&quot;&quot;Verifies if the provided signature is valid for the given sender address.&quot;&quot;&quot;<br>    try:<br>        message_hash = encode_defunct(text=message)<br>        recovered_address = Account.recover_message(message_hash, signature=signature)<br>        return recovered_address.lower() == sender.lower()<br>    except Exception:<br>        return False  # Any error in signature recovery means invalid signature<br><br>@app.post(&quot;/transfer&quot;)<br>async def transfer(data: TransferRequest) -&gt; JSONResponse:<br>    &quot;&quot;&quot;Handles token transfers using signature-based authentication.&quot;&quot;&quot;<br>    message = f&quot;Transfer {data.amount} to {data.receiver}&quot;<br><br>    if not verify_signature(data.sender, message, data.signature):<br>        raise HTTPException(status_code=401, detail=&quot;Invalid signature&quot;)<br><br>    if balances.get(data.sender, 0) &lt; data.amount:<br>        raise HTTPException(status_code=400, detail=&quot;Insufficient balance&quot;)<br><br>    balances[data.sender] -= data.amount<br>    balances[data.receiver] = balances.get(data.receiver, 0) + data.amount<br>    return JSONResponse({&quot;message&quot;: &quot;Transfer successful&quot;})</pre><h3>2. Consistent Replication with Zellular</h3><p>Next, we must replicate our service on different nodes to remove any single point of failure and make it fault tolerant. This replication should be implemented in a way that all nodes maintain an identical, <strong>consistent state</strong> of token balances. If each node were to process transactions independently, their states could diverge, leading to inconsistencies.</p><p>To prevent this, we introduce a <strong>replication mechanism </strong>using<strong> Zellular</strong>. In this approach, nodes first forward transfer requests received from users to the Zellular sequencer. The sequencer orders these requests, and nodes then pull the ordered transactions from Zellular before applying them to their local databases and updating token balances. This ensures that every node maintains a consistent and synchronized state, eliminating the risk of divergence and guaranteeing fault tolerance.</p><p>Here’s how we update our service to integrate with the Zellular sequencer:</p><pre>from zellular import Zellular<br><br># Initialize Zellular<br>zellular = Zellular(&quot;token&quot;, &quot;http://37.27.41.237:6001/&quot;)<br><br>@app.post(&quot;/transfer&quot;)<br>async def transfer(data: TransferRequest) -&gt; JSONResponse:<br>    &quot;&quot;&quot;Handles token transfers using signature-based authentication and sends to Zellular.&quot;&quot;&quot;<br>    message = f&quot;Transfer {data.amount} to {data.receiver}&quot;<br><br>    if not verify_signature(data.sender, message, data.signature):<br>        raise HTTPException(status_code=401, detail=&quot;Invalid signature&quot;)<br><br>    if balances.get(data.sender, 0) &lt; data.amount:<br>        raise HTTPException(status_code=400, detail=&quot;Insufficient balance&quot;)<br><br>    txs = [{<br>        &quot;sender&quot;: data.sender,<br>        &quot;receiver&quot;: data.receiver,<br>        &quot;amount&quot;: data.amount,<br>        &quot;signature&quot;: data.signature<br>    }]<br><br>    zellular.send(txs, blocking=False)<br>    return JSONResponse({&quot;message&quot;: &quot;Transfer sent&quot;})<br><br>def __transfer(data: Dict[str, Any]) -&gt; None:<br>    &quot;&quot;&quot;Executes a transfer after batch processing.&quot;&quot;&quot;<br>    sender, receiver, amount, signature = (<br>        data[&quot;sender&quot;], data[&quot;receiver&quot;], data[&quot;amount&quot;], data[&quot;signature&quot;]<br>    )<br><br>    message = f&quot;Transfer {amount} to {receiver}&quot;<br>    if not verify_signature(sender, message, signature):<br>        logger.error(f&quot;Invalid signature: {data}&quot;)<br>        return<br><br>    if balances.get(sender, 0) &lt; amount:<br>        logger.error(f&quot;Insufficient balance: {data}&quot;)<br>        return<br><br>    balances[sender] -= amount<br>    balances[receiver] = balances.get(receiver, 0) + amount<br>    logger.info(f&quot;Transfer successful: {data}&quot;)<br><br>def process_loop() -&gt; None:<br>    &quot;&quot;&quot;Continuously processes incoming batches from Zellular.&quot;&quot;&quot;<br>    for batch, index in zellular.batches():<br>        txs = json.loads(batch)<br>        for tx in txs:<br>            __transfer(tx)<br><br>Thread(target=process_loop).start()</pre><h3>3. Verifiable Reading with Signature Aggregation</h3><p>At this stage, we have successfully decentralized the <strong>transfer route</strong> of our token service, which handles updates. Now, the next step is to decentralize and make the <strong>balance route</strong>, which handles reads, fully verifiable.</p><p>To achieve this, we leverage <strong>BLS signature aggregation</strong> for balance queries. Instead of relying on a single node to report a balance, we require a majority of nodes to sign their responses to each balance query. These signatures are then aggregated by a signature aggregator, allowing anyone querying a balance to independently verify that the response has been validated by a supermajority of nodes.</p><p>This mechanism is crucial for ensuring trust, especially when other independently hosted verifiable services, such as exchanges, rely on the token service. By making these reading routes verifiable, we enable services to independently access and verify each other’s state in a <strong>trustless and tamper-proof</strong> manner.</p><p>Here’s how we modify our <strong><em>GET </em></strong>balance method to return a BLS signature on its response:</p><pre>from blspy import PopSchemeMPL, PrivateKey<br><br>BLS_PRIVATE_KEY = &quot;BLSPrivateKeyHexHere&quot;<br>sk = PrivateKey.from_bytes(bytes.fromhex(private))<br><br>@app.get(&quot;/balance&quot;)<br>async def balance(address: str) -&gt; Dict[str, Any]:<br>    &quot;&quot;&quot;Retrieves the balance of a given address and returns a BLS-signed message.&quot;&quot;&quot;<br>    balance = balances.get(address, 0)<br>    message = f&quot;Address: {address}, Balance: {balance}&quot;.encode(&quot;utf-8&quot;)<br>    signature = PopSchemeMPL.sign(sk, message)<br>    return {&quot;address&quot;: address, &quot;balance&quot;: balance, &quot;signature&quot;: str(signature)}</pre><h3>Conclusion</h3><p>Following these steps, we have successfully transformed a simple centralized token service into a <strong>fully decentralized verifiable token service </strong>that can be hosted on<strong> EigenLayer</strong> nodes network<strong>.</strong></p><h3>Key Takeaways:</h3><p>✅ <strong>Signature-based authentication</strong> replaces centralized credentials with cryptographic verification<br>✅ <strong>Zellular’s sequencing</strong> ensures transaction order consistency across all nodes<br>✅ <strong>BLS signature aggregation</strong> enables verifiable balance queries</p><p>All code related to different versions of our token service, the signature aggregator, and aggregated signature verification scripts can be found <a href="https://github.com/zellular-xyz/zsequencer/tree/usecases/usecases/token">here</a>.</p><p>This approach paves the way for a new class of decentralized applications that leverage EigenLayer as a high-performance execution layer, going far beyond simple smart contracts.</p><p>In the next article, we will explore <strong>an exchange as a verifiable service on EigenLayer</strong>, demonstrating how it communicates with the token service as two independent yet interoperable components.</p><p>Would you like to see more examples of decentralized services built on EigenLayer? Let us know!</p><p><em>Zellular is a decentralized sequencer for developing high-throughput dApps (100,000+ TPS) implemented in high-level languages (such as JS, GO and Python) hosted on EigenLayer and other restaking platforms.</em></p><p>Visit <a href="https://www.zellular.xyz/">Zellular’s website</a>.</p><p>Join <a href="https://discord.gg/Uemh8Rj3">Zellular’s community</a> on discord.</p><p>Follow <a href="https://x.com/zellular_xyz">Zellular on Twitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ecf093615c7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zellular/hosting-a-token-as-a-verifiable-service-on-eigenlayer-2ecf093615c7">Hosting a Token as a Verifiable Service on EigenLayer</a> was originally published in <a href="https://medium.com/zellular">Zellular</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leveraging Zellular for Decentralized Database Replication within an AVS]]></title>
            <link>https://medium.com/zellular/leveraging-zellular-for-decentralized-database-replication-within-an-avs-89d75c359432?source=rss----a4d57653d15a---4</link>
            <guid isPermaLink="false">https://medium.com/p/89d75c359432</guid>
            <category><![CDATA[sequencer]]></category>
            <category><![CDATA[av]]></category>
            <category><![CDATA[decentralized-database]]></category>
            <category><![CDATA[eigenlayer]]></category>
            <category><![CDATA[eigenlayer-avs]]></category>
            <dc:creator><![CDATA[PASLAR]]></dc:creator>
            <pubDate>Mon, 02 Dec 2024 12:06:32 GMT</pubDate>
            <atom:updated>2024-12-02T12:06:15.267Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SNc2HnNnr3FZ1xrI" /></figure><p>In <a href="https://medium.com/zellular/enhancing-avs-efficiency-using-zellular-sequencer-for-task-management-b10c36c56c79?source=collection_home---6------0-----------------------">our previous article</a>, we introduced <a href="https://www.zellular.xyz/">Zellular</a> as a decentralized task manager for Actively Validated Services (AVS). Now, we dive deeper into its capabilities, focusing on <strong>how Zellular enables decentralized database replication among AVS nodes.</strong></p><p>Developers often turn to blockchains for data consensus across nodes, but this comes with high costs and limited scalability. Zellular sequencer offers a more efficient alternative, allowing AVS to replicate data directly on their nodes while maintaining consensus — without the drawbacks of blockchain reliance.</p><h3>A Practical Example: Logging AVS Node Downtime</h3><p>Downtime logs are critical data that require consensus among all AVS nodes, as they directly influence fee and penalty structures. A reliable sub-module for monitoring downtimes of nodes is essential for many AVS, serving as the backbone for their reward and penalty systems.</p><p>To demonstrate Zellular’s utility, let’s consider the essential task of logging the downtimes of AVS nodes and replicating that data across the nodes using the Zellular sequencer.</p><h4>Detecting &amp; Validating Node Downtime</h4><p>In AVS architecture, <strong>an aggregator typically queries nodes about validating the tasks</strong> they are responsible for and <strong>collects their validation signatures</strong>. Aggregators are often the first to detect when a node fails to respond with its validation signature, potentially indicating downtime.</p><p>However, relying solely on the aggregator’s claims regarding node downtime is insufficient for a decentralized system, as the aggregator itself could act maliciously and make untruthful claims that put financial costs on individual nodes. To ensure reliability, we need a system where AVS nodes can independently validate the uptime or downtime of other nodes as a secondary task.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XedK7b7HFL5n2BWw" /></figure><p>To achieve this, each AVS node must have <strong>a designated endpoint</strong> that allows the aggregator to query them with the ID of a node suspected of being down. This enables nodes to confirm or refute the downtime status independently. A node’s downtime is logged only when a threshold of nodes confirms it.</p><p>Note that to have the sum of node downtime in a certain period, nodes’ uptime must also be detected and validated in the same way.</p><h4>Hosting Downtime Data on AVS nodes</h4><p>Once the downtime/uptime events of a specific node are validated by the other nodes and their confirmations are collected, the corresponding signatures must be <strong>aggregated and stored in a decentralized database</strong>.</p><p>The popular approach among Web3 developers is to use Blockchains to store such data in a decentralised way. However, by <strong>enabling AVS to store the proofs on its own nodes</strong>, Zellular offers a <strong>faster</strong>, <strong>cheaper</strong> and therefore <strong>more scalable</strong> solution.</p><p>Let’s explore how Zellular can help store the data within AVS nodes while guaranteeing consensus among them.</p><p>First, the aggregator must post each aggregated proof to the Zellular sequencer:</p><pre>zellular = zellular.Zellular(&quot;avs-liveness-checker&quot;, base_url)<br>zellular.send([{&#39;node&#39;: 8, &#39;event_type&#39;: &#39;down&#39;, timestamp: , 1732522695, &#39;sig&#39;: &#39;0x23a3...46da&#39;}])</pre><p>AVS nodes, on the other hand, constantly listen to receive the proofs from the Zellular sequencer:</p><pre>zellular = zellular.Zellular(&quot;avs-liveness-checker&quot;, base_url)<br>for batch, index in self.zellular.batches(after=index):<br>    events = json.loads(batch)<br>    for i, event in enumerate(events):<br>        if verify(event):<br>            add_event_log(event)</pre><p>AVS nodes verify each proof they receive from the Zellular sequencer. When a threshold of nodes (a predefined number of nodes, for instance 15 out of 20) has confirmed the event, they add the corresponding downtime/uptime to the log lists in their local database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DNRaKyqbfiHlTNqj" /></figure><p>Using Zellular in this architecture not only <strong>guarantees that no event is missed</strong> <strong>in any node’s log list</strong>, but also <strong>ensures all nodes store the same sequence</strong> <strong>of downtime/uptime events</strong>. Therefore, if a query is made to retrieve the total downtime of a node over a specific period, all nodes will <strong>calculate and return identical responses</strong>. This consistency is critical for decentralized reward and penalty mechanisms.</p><h3>The Future of Decentralized AVS Architecture</h3><p>Zellular isn’t just a replacement for blockchain in AVS task management or data hosting — it’s a <strong>foundational tool for building high-performance, decentralized applications</strong>. Whether for task queues, data replication, or other consensus-critical services, Zellular offers unmatched efficiency and scalability.</p><p><em>Zellular is a decentralized sequencer for developing high-throughput dApps (100,000+ TPS) implemented in high-level languages (such as JS, GO and Python) hosted on EigenLayer and other restaking platforms.</em></p><p>Visit <a href="https://www.zellular.xyz/">Zellular’s website</a>.</p><p>Join <a href="https://discord.gg/Uemh8Rj3">Zellular’s community</a> on discord.</p><p>Follow <a href="https://x.com/zellular_xyz">Zellular on Twitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89d75c359432" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zellular/leveraging-zellular-for-decentralized-database-replication-within-an-avs-89d75c359432">Leveraging Zellular for Decentralized Database Replication within an AVS</a> was originally published in <a href="https://medium.com/zellular">Zellular</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing AVS Efficiency Using Zellular Sequencer for Task Management]]></title>
            <link>https://medium.com/zellular/enhancing-avs-efficiency-using-zellular-sequencer-for-task-management-b10c36c56c79?source=rss----a4d57653d15a---4</link>
            <guid isPermaLink="false">https://medium.com/p/b10c36c56c79</guid>
            <category><![CDATA[eigenlayer]]></category>
            <category><![CDATA[task-management]]></category>
            <category><![CDATA[zellular]]></category>
            <category><![CDATA[restaking]]></category>
            <category><![CDATA[decentralisation]]></category>
            <dc:creator><![CDATA[PASLAR]]></dc:creator>
            <pubDate>Mon, 30 Sep 2024 13:46:20 GMT</pubDate>
            <atom:updated>2024-09-30T17:31:38.686Z</atom:updated>
            <content:encoded><![CDATA[<h4>Zellular providing a cost-efficient and high-throughput task manager for EigenLayer AVS</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tw0SRBITjM-oA9J-OkKI0Q.jpeg" /></figure><p>EigenLayer platform allows Ethereum stakers to repurpose their staked ETH to secure new decentralised services. By restaking, EigenLayer extends Ethereum’s security to additional applications and protocols as Actively Validated Services (AVS). <strong>With AVS, you can leverage Ethereum’s robust security to run specialized tasks or services without building your own security infrastructure.</strong> This opens up new opportunities for decentralized applications to innovate securely and efficiently.</p><h3>AVSs &amp; Task Management</h3><p>When building a decentralised service as an EigenLayer AVS, <strong>the first step is to define the tasks that validators will perform</strong>. For example, in the popular <a href="https://github.com/Layr-Labs/incredible-squaring-avs">“Incredible Squaring AVS”</a> sample, nodes are responsible for calculating the square of a number provided by a task generator through a <a href="https://github.com/Layr-Labs/incredible-squaring-avs/blob/master/contracts/src/IIncredibleSquaringTaskManager.sol">task manager contract</a>.</p><p>Typically, AVS developers use blockchain smart contracts to manage their tasks. However, relying on the blockchain can be expensive and slow.</p><iframe src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/weswfloyd/status/1792178211347992838&amp;image=" width="500" height="281" frameborder="0" scrolling="no"><a href="https://medium.com/media/14496ef1ba573c36687df3bc992b1008/href">https://medium.com/media/14496ef1ba573c36687df3bc992b1008/href</a></iframe><h3>Zellular as a Decentralised Messaging Queue</h3><p>Zellular, a lightweight consensus-as-a-service AVS, serves as <strong>an excellent alternative to blockchain smart contracts</strong> <strong>for AVS task management</strong>. It operates more simply, efficiently, and cost-effectively, boasting a much higher throughput. Any AVS can use Zellular as a decentralized messaging queue to share events among their nodes.</p><p>Let’s explore how to update the Incredible Squaring AVS to use Zellular instead of a blockchain for task management.</p><h4>Step 1: Connecting to Zellular</h4><p>First, an object needs to be built to connect to Zellular as the task manager. To do that, replace the following code block that connects to the task manager smart contract:</p><pre>def __load_task_manager(self):<br>    web3 = Web3(Web3.HTTPProvider(self.config[&quot;eth_rpc_url&quot;]))<br><br>    service_manager_address = <br>        self.clients.avs_registry_writer.service_manager_addr<br>    with open(&quot;abis/IncredibleSquaringServiceManager.json&quot;) as f:<br>        service_manager_abi = f.read()<br>    service_manager = web3.eth.contract(<br>        address=service_manager_address, abi=service_manager_abi<br>    )<br><br>    task_manager_address = (<br>        service_manager.functions.incredibleSquaringTaskManager().call()<br>    )<br>    with open(&quot;abis/IncredibleSquaringTaskManager.json&quot;) as f:<br>        task_manager_abi = f.read()<br>    self.task_manager = web3.eth.contract(<br>        address=task_manager_address, abi=task_manager_abi)</pre><p>with the following code block that connects to Zellular as the task manager:</p><pre>def __load_zellular(self):<br>    operators = zellular.get_operators()<br>    base_url = random.choice(operators)[&quot;socket&quot;]<br>    app_name = &quot;incredible-squaring&quot;<br>    self.zellular = zellular.Zellular(app_name, base_url)</pre><h4>Step 2: Posting Tasks to Zellular</h4><p>The next step is for the task generator to post tasks to Zellular instead of a blockchain. To do so, replace the code block for posting to the blockchain:</p><pre>def send_new_task(self, i):<br>    tx = self.task_manager.functions.createNewTask(<br>        i, 100, nums_to_bytes([0])<br>    ).build_transaction({<br>        &quot;from&quot;: self.aggregator_address,<br>        &quot;gas&quot;: 2000000,<br>        &quot;gasPrice&quot;: self.web3.to_wei(&quot;20&quot;, &quot;gwei&quot;),<br>        &quot;nonce&quot;: self.web3.eth.get_transaction_count(<br>            self.aggregator_address<br>        ),<br>        &quot;chainId&quot;: self.web3.eth.chain_id,<br>    })<br>    signed_tx = self.web3.eth.account.sign_transaction(<br>        tx, private_key=self.aggregator_ecdsa_private_key<br>    )<br>    tx_hash = self.web3.eth.send_raw_transaction(<br>        signed_tx.rawTransaction<br>    )<br>    receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)<br>    event = self.task_manager.events.NewTaskCreated().process_log(<br>                 receipt[&#39;logs&#39;][0])<br><br>    task_index = event[&#39;args&#39;][&#39;taskIndex&#39;]</pre><p>with the following code block for posting to Zellular:</p><pre>def send_new_task(self, i):<br>    task = {<br>        &quot;numberToBeSquared&quot;: i,<br>        &quot;quorumNumbers&quot;: [0],<br>        &quot;quorumThresholdPercentage&quot;: 100,<br>    }<br>    task_index = self.zellular.send([task], blocking=True)</pre><h4>Step 3: Getting Tasks from Zellular</h4><p>The last step is to update the squaring operators to listen for NewTaskCreated events on Zellular instead of a blockchain. For that, replace the code block for listening to events emitted by the task manager contract:</p><pre>def start(self):<br>    logger.info(&quot;Starting Operator...&quot;)<br>    event_filter = self.task_manager.events.NewTaskCreated.create_filter(<br>        fromBlock=&quot;latest&quot;<br>    )<br>    while True:<br>        for event in event_filter.get_new_entries():<br>            logger.info(f&quot;New task created: {event}&quot;)<br>            self.process_task_event(event)</pre><p>with the code block that listens to Zellular for getting events:</p><pre>def start(self):<br>    logger.info(&quot;Starting Operator...&quot;)<br>    index = self.zellular.get_last_finalized()[&quot;index&quot;]<br><br>    for batch, index in self.zellular.batches(after=index):<br>        events = json.loads(batch)<br>        for i, event in enumerate(events):<br>            logger.info(f&quot;New task created: {event}&quot;)<br>            self.process_task_event(event)</pre><p>Note that what we reviewed above, about using Zellular as the task manager of incredible squaring, is not a complete working solution, but a mere example to demonstrate how an AVS integration with Zellular works out.</p><p>Find out more about Zellular integration at <a href="http://docs.zellular.xyz/">docs.zellular.xyz</a>.</p><h3>Zellular ＞ Blockchain for AVS Task Management</h3><h4>Costs and Throughput</h4><p>The most significant problem with using a blockchain for AVS task management is <strong>its high costs</strong>. The costs are not limited to posting transactions for emitting events. Reading events from the blockchain through third-party RPC or subgraph service providers incurs higher costs compared to sending the transactions that emit the events. This is especially true since each AVS node must pay these costs separately; having tens of nodes results in the expenses multiplying tens of times!</p><p>Costs are not the only problem with using blockchains. AVS services often need high throughput rates that are simply not possible on blockchains. <strong>Using Zellular provides far higher throughput while curbing the costs exponentially</strong>. But that’s not all!</p><h4>Decentralization and Security</h4><p>All nodes in an AVS typically use an RPC or subgraph service run by a third-party provider to access the blockchain. They do not run a blockchain node themselves, which introduces the risk of a single point of failure and reduces the AVS’s security.</p><p>In contrast, when events are read from Zellular instead of a blockchain, there is no need to rely on third-party providers. Events can be directly read from Zellular AVS nodes. Additionally, even though events can be received from any random Zellular node, there is always <strong>an aggregated signature on all responses</strong>, <strong>proving that the majority of Zellular nodes have verified the data’s validity</strong>. Unlike using blockchain, Zellular removes the need for trust in any individual node to read the events.</p><h3>Beyond Task Management</h3><p>Zellular’s utility for AVS goes beyond task management. Many AVS use a blockchain as their shared database with consensus. Zellular can also enable AVS to host such a database off-chain on their own nodes while maintaining decentralization and consensus.</p><p>The next article will focus on this use case, exploring how Zellular can further enhance decentralised applications by providing efficient and secure off-chain databases.</p><p><strong><em>Zellular is a decentralized sequencer to develope high-throughput dApps (500,000+ TPS) implemented in high-level languages (such as JS, GO and Python) hosted on EigenLayer and other restaking platforms.</em></strong></p><p><strong><em>Visit Zellular’s </em></strong><a href="https://www.zellular.xyz/"><strong><em>website</em></strong></a><strong><em>.</em></strong></p><p><strong><em>Join Zellular’s community </em></strong><a href="https://discord.com/invite/zellular"><strong><em>discord</em></strong></a><strong><em>.</em></strong></p><p><strong><em>Follow Zellular on </em></strong><a href="https://x.com/zellular_xyz"><strong><em>Twitter</em></strong></a><strong><em>.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b10c36c56c79" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zellular/enhancing-avs-efficiency-using-zellular-sequencer-for-task-management-b10c36c56c79">Enhancing AVS Efficiency Using Zellular Sequencer for Task Management</a> was originally published in <a href="https://medium.com/zellular">Zellular</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Breaking Free from Centralized Apps]]></title>
            <link>https://medium.com/zellular/breaking-free-from-centralized-apps-285b87e4fabb?source=rss----a4d57653d15a---4</link>
            <guid isPermaLink="false">https://medium.com/p/285b87e4fabb</guid>
            <category><![CDATA[decentralization]]></category>
            <category><![CDATA[sdk]]></category>
            <category><![CDATA[eigenlayer]]></category>
            <category><![CDATA[secure-messengers]]></category>
            <category><![CDATA[social-media]]></category>
            <dc:creator><![CDATA[PASLAR]]></dc:creator>
            <pubDate>Fri, 13 Sep 2024 11:06:38 GMT</pubDate>
            <atom:updated>2024-09-25T10:46:22.104Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong><em>How EigenLayer and Zellular Are Changing the Game</em></strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6KRVreTszOwnUwqEkwYjQ.png" /></figure><p>In August 2024, Telegram CEO Pavel Durov was arrested in France over allegations that the platform was used for illegal activities. After his release, Telegram made a quiet but significant policy shift, allowing users to report private chats to moderators. For an app known for its commitment to privacy, this change raised some eyebrows and sparked concerns about whether outside forces, like governments, could influence how platforms handle user data and privacy.</p><p>Durov’s arrest ignited broader discussions about free speech and the power that governments have over social media platforms. It led to a bigger question: what if entire platforms could be shut down or specific users silenced, just because their actions don’t align with certain government agendas?</p><p>This situation underscored the need for greater transparency in how these platforms are run. Instead of decisions being made behind closed doors, there should be open, decentralized systems that allow users to have a say and protect their rights from external interference.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/902/1*jxDvYtqKQNjQGWSgGD3Wrw.jpeg" /></figure><h3>Why Decentralized Messengers Haven’t Taken Off (Yet)</h3><p>Despite the rise of blockchain technology, building large-scale decentralized messaging apps still faces big challenges. The main hurdle? Scalability. Blockchains struggle to manage the huge amount of data and millions of users found on popular messaging platforms.</p><p>To function, the huge amount of data must be replicated among thousands of blockchain nodes which are far from having the capacity for. This also requires consensus among large numbers of blockchain nodes, which slows down the process and makes it difficult to handle the real-time nature of messaging apps like WhatsApp or Telegram. These technical limitations is why, even after more than a decade of advancements, we still don’t have a fully decentralized communication service.</p><h3>Enter EigenLayer: The Future of Decentralized Apps</h3><p><a href="https://www.eigenlayer.xyz/">EigenLayer</a> is changing the game by offering new ways to create decentralized applications, or “BFT (Byzantine Fault Tolerant) services,” without being limited by blockchain’s scalability issues. With EigenLayer, you can replicate any Web2 service — think about any of your favorite apps — across a network of nodes. Essentially, it creates multiple instances of these services, offering better security and decentralization.</p><p>BFT services are a huge step up from traditional Web2 distributed systems. In Web2, we assume that the only thing that can go wrong is a server going down. In BFT systems, however, malicious attacks are expected and countered. Even if a few nodes are compromised, the service keeps running smoothly —<strong><em> this is the key difference between distributed and decentralized systems.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*da5qcXvdll4jjDiKcF_xkA.png" /><figcaption><a href="https://www.eigenlayer.xyz/">eigenlayer.yxz</a></figcaption></figure><h3>How to Replicate Signal as a BFT Service</h3><p>Let’s take Signal, the popular encrypted open-source messaging platform, as an example. To turn it into a BFT service on EigenLayer, the first step would be to switch its session-based authentication to signature-based authentication. This enables each of the service nodes to independently verify user-issued requests. Tools like Web3Auth and Privy make this easy, allowing users to log in with the same seamless experience they’re used to, while the app handles the signature-based authentication behind the scenes.</p><p>Next, we would need multiple nodes to run Signal’s service. Normally, user updates would go to Signal’s central server. But in this case, the updates would be shared across all nodes using <a href="https://www.zellular.xyz/">Zellular</a> which acts like a decentralized messaging queue built on EigenLayer (like a decentralized version of Kafka). Every time a node receives an update request, it sends it to Zellular, which then distributes it back to all nodes. This ensures that every node processes the same updates in the same order, achieving consensus across the network.</p><p><strong><em>The best part? There’s no need to change anything in Signal’s code to achieve replication.</em></strong> A simple middleware layer can be added to route certain HTTP requests (like POST, PUT, and DELETE) through Zellular before they reach the service itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JqeXaXdBVPOfRwNkp_ImVQ.png" /></figure><h3>Keeping Data Transfers Secure</h3><p>This replication method applies only to update requests. GET requests, which are used to read data, can be queried from any node. However, when it comes to sensitive data, like server-side data that must be validated, Zellular’s SDK offers tools to ensure the integrity of the information. Sensitive data must be validated by a threshold number of nodes through a process called threshold signatures. This ensures that even if a few nodes are compromised, the data remains verifiable and secure.</p><p>It’s important to clarify that sensitive data refers to server-side data and not information like private keys which are always stored on the client side and never shared with servers. For instance, in an exchange, the wallet address shared by servers for user deposits is considered sensitive because a hacked server could lead to lost deposits. By using a threshold of node signatures, such sensitive data becomes verifiable by clients, ensuring security even in a decentralized environment.</p><p><em>With Zellular and EigenLayer, the possibilities for Web3 apps are limitless. From decentralized messaging to fully verifiable, censorship-resistant services, these technologies are transforming how we build and interact with digital platforms. By harnessing the power of decentralization, Web3 apps on EigenLayer offer unparalleled security, transparency, and user control, making the internet truly open and free for everyone.</em></p><p><strong><em>Zellular is a light-weight consensus layer and decentralized sequencer that enables developing high-throughput dapps (500,000+ TPS) implemented in high-level languages (such as JS, GO and Python), and hosted on EigenLayer and other re-staking platforms to ensure security.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=285b87e4fabb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zellular/breaking-free-from-centralized-apps-285b87e4fabb">Breaking Free from Centralized Apps</a> was originally published in <a href="https://medium.com/zellular">Zellular</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>